@mp-front/common 0.0.2-next.0 → 0.0.2-next.2

package/README.md

@@ -1,373 +1,202 @@
-# @mp-front/common - Documentación Técnica
+# @mp-front/common
 
-## 📚 Tabla de Contenidos
+Una librería integral de TypeScript para aplicaciones frontend con autenticación, caché, cliente HTTP y utilidades de middleware construida con RxJS y patrones modernos.
 
-1. [Arquitectura General](#arquitectura-general)
-2. [Módulos y Componentes](#módulos-y-componentes)
-3. [Guías de Implementación](#guías-de-implementación)
-4. [Configuración](#configuración)
-5. [Casos de Uso Avanzados](#casos-de-uso-avanzados)
+## Comenzando
 
----
+### Instalación
 
-## 🏗️ Arquitectura General
-
-La biblioteca `@mp-front/common` está diseñada con una arquitectura modular que permite importar solo los componentes necesarios, optimizando el tamaño del bundle final.
+```bash
+npm install @mp-front/common
+```
 
-### Estructura de Directorios
+### Dependencias Peer
 
+```bash
+npm install ioredis@5.3.2 next-auth@4.24.13 node-jose@2.2.0 rxjs@7.8.1
 ```
-src/
-├── adapters/          # Adaptadores NextAuth (Redis)
-├── auth/              # Servicios de autenticación
-├── cache/             # Gestión de caché
-│   ├── session-handler/    # Manejo de sesiones
-│   └── terminal-handler/   # Manejo de terminales
-├── cache-providers/   # Proveedores de caché
-│   └── redis/             # Implementación Redis
-├── engine/            # Motor de autenticación Azure
-├── errors/            # Sistema de errores
-├── helpers/           # Utilidades generales
-├── http/              # Cliente HTTP
-├── middleware/        # Middlewares API
-└── rxjs/              # Utilidades RxJS
-```
 
-### Principios de Diseño
+### Inicio Rápido
+
+```typescript
+import { HttpClient } from '@mp-front/common/http'
+import { Logger } from '@mp-front/common/helpers'
 
-- **Modularidad**: Cada módulo es independiente y puede importarse por separado
-- **Programación Reactiva**: Uso extensivo de RxJS para operaciones asíncronas
-- **Type Safety**: TypeScript completo con tipos estrictos
-- **Singleton Pattern**: Para gestores globales (ErrorHandler, LoadingHandler)
-- **Encriptación**: Seguridad en datos sensibles con node-jose
+const client = new HttpClient()
+const logger = new Logger()
 
----
+client.get('/api/users').subscribe(users => {
+  logger.logInfo('Usuarios cargados', JSON.stringify(users))
+})
+```
 
-## 📦 Módulos y Componentes
+## Arquitectura
 
-### 1. Auth Module (`@mp-front/common/auth`)
+La librería sigue una arquitectura modular que permite tree-shaking e importaciones selectivas:
 
-#### AuthorizationService
+```
+@mp-front/common/
+├── auth              # Servicios de autenticación
+├── engine            # Integración con Azure Entra ID
+├── http              # Cliente HTTP con RxJS
+├── cache             # Caché de sesión y terminal
+├── cache-providers   # Implementación de caché Redis
+├── helpers           # Utilidades (Logger, Encoder, Encrypter)
+├── errors            # Sistema de manejo de errores
+├── rxjs              # Utilidades y manejadores RxJS
+├── middleware        # Middleware de API para Next.js
+└── adapters          # Adaptadores NextAuth
+```
 
-Servicio para obtener tokens de autenticación desde un backend.
+## Referencia de API
 
-**Características:**
+### Autenticación
 
-- Autenticación mediante credenciales
-- Retorna Observable con el token
-- Logging integrado de requests/responses
+#### AuthorizationService
 
-**Implementación:**
+Servicio para autenticación de tokens del backend.
 
 ```typescript
-import { AuthorizationService } from "@mp-front/common/auth"
+import { AuthorizationService } from '@mp-front/common/auth'
 
 const authService = new AuthorizationService()
 
-// Obtener token
 authService.get().subscribe({
-  next: token => {
-    console.log("Token obtenido:", token)
-    // Usar token en headers
-  },
-  error: error => {
-    console.error("Error de autenticación:", error)
-  },
+  next: token => console.log('Token:', token),
+  error: error => console.error('Error de auth:', error)
 })
 ```
 
-**Variables de entorno requeridas:**
-
+**Variables de Entorno:**
 ```env
 API_AUTH_BACK_URL=https://api.example.com/auth
-API_AUTH_BACK_USERNAME_AUTH=your_username
-API_AUTH_BACK_PASSWORD_AUTH=your_password
+API_AUTH_BACK_USERNAME_AUTH=username
+API_AUTH_BACK_PASSWORD_AUTH=password
 ID_FRONT=frontend-app-id
 ```
 
----
-
-### 2. Engine Module (`@mp-front/common/engine`)
+### Motor Azure
 
 #### AuthEngine
 
-Motor de autenticación para Azure Entra ID (anteriormente Azure AD).
-
-**Características:**
-
-- Verificación de roles de usuario
-- Verificación de grupos de usuario
-- Integración con Microsoft Graph API
-
-**Métodos principales:**
-
-##### `getRoles(email: string, idObjApp: string)`
-
-Obtiene los roles asignados a un usuario en una aplicación.
+Integración con Azure Entra ID para verificación de roles y grupos.
 
 ```typescript
-import { AuthEngine } from "@mp-front/common/engine"
+import { AuthEngine } from '@mp-front/common/engine'
 
 const authEngine = new AuthEngine()
 
-authEngine.getRoles("user@example.com", "app-object-id").subscribe({
-  next: ({ roles }) => {
-    console.log("Roles del usuario:", roles)
-  },
+// Verificar roles de usuario
+authEngine.getRoles('user@example.com', 'app-object-id').subscribe({
+  next: ({ roles }) => console.log('Roles del usuario:', roles)
 })
-```
-
-##### `inRole(email: string, idRole: string, idObjApp: string)`
 
-Verifica si un usuario tiene un rol específico.
-
-```typescript
-authEngine.inRole("user@example.com", "role-id", "app-object-id").subscribe({
-  next: hasRole => {
-    if (hasRole) {
-      console.log("Usuario tiene el rol")
-    }
-  },
+// Verificar rol específico
+authEngine.inRole('user@example.com', 'role-id', 'app-object-id').subscribe({
+  next: hasRole => console.log('Tiene rol:', hasRole)
 })
-```
 
-##### `inGroup(email: string, idGroup: string)`
-
-Verifica si un usuario pertenece a un grupo.
-
-```typescript
-authEngine.inGroup("user@example.com", "group-id").subscribe({
-  next: inGroup => {
-    if (inGroup) {
-      console.log("Usuario pertenece al grupo")
-    }
-  },
+// Verificar membresía de grupo
+authEngine.inGroup('user@example.com', 'group-id').subscribe({
+  next: inGroup => console.log('En grupo:', inGroup)
 })
 ```
 
-**Variables de entorno requeridas:**
-
+**Variables de Entorno:**
 ```env
 AZURE_AD_GRAPH_GET_APP_ROLES=https://graph.microsoft.com/v1.0/applications/{id-obj}/appRoles
 AZURE_AD_GRAPH_GET_USER_BY_EMAIL=https://graph.microsoft.com/v1.0/users/{user-mail}
 AZURE_AD_GRAPH_GROUPS=https://graph.microsoft.com/v1.0/users/idUser/memberOf
 ```
 
----
-
-### 3. HTTP Module (`@mp-front/common/http`)
+### Cliente HTTP
 
 #### HttpClient
 
-Cliente HTTP basado en RxJS con características avanzadas.
-
-**Características:**
-
-- Métodos HTTP: GET, POST, PUT, PATCH, DELETE
-- Encoding/Decoding automático de datos
-- Manejo de loading state global
-- Manejo de errores centralizado
-- Logging de requests/responses
-
-**Métodos:**
-
-##### GET Request
+Cliente HTTP basado en RxJS con estados de carga automáticos y manejo de errores.
 
 ```typescript
-import { HttpClient } from "@mp-front/common/http"
+import { HttpClient } from '@mp-front/common/http'
 
 const client = new HttpClient()
 
-interface User {
-  id: number
-  name: string
-  email: string
-}
-
-client.get<User>("/api/users/1").subscribe({
-  next: user => {
-    console.log("Usuario:", user)
-  },
-  error: error => {
-    console.error("Error:", error)
-  },
+// Petición GET
+client.get<User[]>('/api/users', {
+  params: { page: 1, limit: 10 },
+  headers: { 'Authorization': 'Bearer token' }
+}).subscribe(users => {
+  console.log('Usuarios:', users)
 })
 
-// Con parámetros
-client
-  .get<User[]>("/api/users", {
-    params: { page: 1, limit: 10 },
-  })
-  .subscribe(users => {
-    console.log("Usuarios:", users)
-  })
-```
-
-##### POST Request
-
-```typescript
-client
-  .post<User>("/api/users", {
-    name: "John Doe",
-    email: "john@example.com",
-  })
-  .subscribe(newUser => {
-    console.log("Usuario creado:", newUser)
-  })
-```
-
-##### PUT Request
-
-```typescript
-client
-  .put<User>("/api/users/1", {
-    name: "Jane Doe",
-  })
-  .subscribe(updatedUser => {
-    console.log("Usuario actualizado:", updatedUser)
-  })
-```
-
-##### DELETE Request
-
-```typescript
-client.delete("/api/users/1").subscribe(() => {
-  console.log("Usuario eliminado")
+// Petición POST
+client.post<User>('/api/users', {
+  name: 'Juan Pérez',
+  email: 'juan@example.com'
+}).subscribe(newUser => {
+  console.log('Creado:', newUser)
 })
-```
 
-##### Deshabilitar Loading Global
-
-```typescript
-const client = new HttpClient()
+// Deshabilitar carga global
 client.setIsLoadingEnabled(false)
-
-// Este request no activará el loading global
-client.get("/api/data").subscribe(data => {
-  console.log(data)
-})
 ```
 
----
+**Métodos:**
+- `get<T>(url, options?)` - Petición GET
+- `post<T>(url, body, options?)` - Petición POST  
+- `put<T>(url, body, options?)` - Petición PUT
+- `patch<T>(url, body, options?)` - Petición PATCH
+- `delete<T>(url, options?)` - Petición DELETE
 
-### 4. Cache Module (`@mp-front/common/cache`)
+### Gestión de Caché
 
 #### SessionCache
 
 Gestión de sesiones de usuario con Redis.
 
-**Características:**
-
-- Almacenamiento de sesión en Redis
-- Renovación automática de timeout
-- Integración con NextAuth
-- Datos de usuario y tienda
-
-**Métodos:**
-
-##### `getBasicSession()`
-
-Obtiene la sesión básica del usuario.
-
 ```typescript
-import { SessionCache } from "@mp-front/common/cache"
+import { SessionCache } from '@mp-front/common/cache'
 
-const sessionCache = new SessionCache("user-id-123")
+const sessionCache = new SessionCache('user-id-123')
 
+// Obtener sesión básica
 const session = await sessionCache.getBasicSession()
+console.log('Usuario:', session.user)
 
-console.log("Usuario:", session.user)
-// {
-//   name: 'John Doe',
-//   email: 'john@example.com',
-//   image: 'https://...',
-//   cveUsuario: '12345',
-//   rol: 'admin',
-//   appGroups: ['group1', 'group2']
-// }
-```
-
-##### `getUserAndShoppingStore()`
-
-Obtiene sesión completa con datos de tienda.
-
-```typescript
+// Obtener sesión completa con datos de tienda
 const fullSession = await sessionCache.getUserAndShoppingStore()
-
-console.log("Sesión completa:", fullSession)
 ```
 
 #### TerminalCache
 
-Gestión de datos de terminal con Redis.
-
-**Características:**
-
-- Almacenamiento por clave de vendedor
-- Generación de UUID único por vendedor
-- Timeout configurable
-
-**Métodos:**
-
-##### `set(sellerKey: string, terminal: TerminalValue)`
-
-Guarda datos de terminal.
+Gestión de datos de terminal.
 
 ```typescript
-import { TerminalCache } from "@mp-front/common/cache"
+import { TerminalCache } from '@mp-front/common/cache'
 
 const terminalCache = new TerminalCache()
 
-await terminalCache.set("SELLER001", {
-  terminalId: "TERM123",
-  location: "Store A",
-  status: "active",
+// Establecer datos de terminal
+await terminalCache.set('SELLER001', {
+  terminalId: 'TERM123',
+  location: 'Tienda A',
+  status: 'active'
 })
-```
-
-##### `get(sellerKey: string)`
 
-Obtiene datos de terminal.
+// Obtener datos de terminal
+const terminal = await terminalCache.get('SELLER001')
 
-```typescript
-const terminal = await terminalCache.get("SELLER001")
-
-if (terminal) {
-  console.log("Terminal:", terminal)
-}
+// Eliminar datos de terminal
+await terminalCache.delete('SELLER001')
 ```
 
-##### `delete(sellerKey: string)`
-
-Elimina datos de terminal.
-
-```typescript
-await terminalCache.delete("SELLER001")
-```
-
----
-
-### 5. Cache Providers Module (`@mp-front/common/cache-providers`)
+### Proveedores de Caché
 
 #### RedisCache
 
-Proveedor genérico de caché con Redis.
-
-**Características:**
-
-- Operaciones CRUD completas
-- Encriptación opcional
-- TTL (Time To Live) configurable
-- Soporte para tipos genéricos
-
-**Métodos:**
-
-##### `set(params: ISetStateParams<T>)`
-
-Guarda datos en Redis.
+Proveedor genérico de caché Redis con soporte de encriptación.
 
 ```typescript
-import { RedisCache } from "@mp-front/common/cache-providers"
+import { RedisCache } from '@mp-front/common/cache-providers'
 
 interface UserData {
   name: string
@@ -376,218 +205,165 @@ interface UserData {
 
 const redis = new RedisCache<UserData>()
 
+// Establecer datos con encriptación
 await redis.set({
-  prefix: "user:123",
-  idData: "profile",
-  body: {
-    name: "John Doe",
-    email: "john@example.com",
-  },
-  expire: 3600, // 1 hora en segundos
-  encrypted: true, // Opcional: encriptar datos
+  prefix: 'user:123',
+  idData: 'profile',
+  body: { name: 'Juan', email: 'juan@example.com' },
+  expire: 3600,
+  encrypted: true
 })
-```
-
-##### `get<T>(prefix: string, idData: string)`
-
-Obtiene datos de Redis.
 
-```typescript
-const { data, sha } = await redis.get<UserData>("user:123", "profile")
-
-console.log("Datos:", data)
-console.log("SHA key:", sha)
-```
-
-##### `delete(prefix: string, idData: string)`
+// Obtener datos
+const { data, sha } = await redis.get<UserData>('user:123', 'profile')
 
-Elimina datos de Redis.
+// Eliminar datos
+await redis.delete('user:123', 'profile')
 
-```typescript
-await redis.delete("user:123", "profile")
+// Operaciones simples
+const value = await redis.simpleGet('key')
+await redis.simpleHSet('hash-key', 'field', 'value')
+const allFields = await redis.simpleHGetAll('hash-key')
 ```
 
-##### Operaciones simples
-
-```typescript
-// GET simple
-const value = await redis.simpleGet("key")
-
-// HGET (hash get)
-const fieldValue = await redis.simpleHGet("hash-key", "field")
-
-// HSET (hash set)
-await redis.simpleHSet("hash-key", "field", "value")
-
-// HGETALL (obtener todo el hash)
-const allFields = await redis.simpleHGetAll("hash-key")
-```
-
-**Variables de entorno:**
-
+**Variables de Entorno:**
 ```env
 REDIS_URL=redis://localhost:6379
 TIMEOUT_SESSION_MINUTES=60
-SECRET_SIGNATURE=your-secret-key-for-encryption
+SECRET_SIGNATURE=tu-clave-secreta-min-32-chars
 ```
 
----
-
-### 6. Helpers Module (`@mp-front/common/helpers`)
+### Utilidades
 
 #### Logger
 
-Sistema de logging con niveles y colores.
-
-**Niveles de log:**
-
-- `error`: Errores críticos
-- `warn`: Advertencias
-- `info`: Información general
-- `http`: Logs HTTP
-- `verbose`: Información detallada
-- `debug`: Debugging
-- `silly`: Todo
-
-**Uso:**
+Logging estructurado con niveles y colores.
 
 ```typescript
-import { Logger } from "@mp-front/common/helpers"
+import { Logger } from '@mp-front/common/helpers'
 
 const logger = new Logger()
 
-logger.logError("Error crítico", JSON.stringify(error))
-logger.logWarn("Advertencia: API deprecated")
-logger.logInfo("Usuario autenticado correctamente")
-logger.logDebug("Datos de request:", JSON.stringify(data))
+logger.logError('Error crítico', JSON.stringify(error))
+logger.logWarn('Uso de API deprecada')
+logger.logInfo('Usuario autenticado exitosamente')
+logger.logDebug('Datos de petición:', JSON.stringify(data))
 ```
 
-**Configuración:**
+**Niveles de Log:** `error`, `warn`, `info`, `http`, `verbose`, `debug`, `silly`
 
+**Variables de Entorno:**
 ```env
-NEXT_PUBLIC_APP_LOGS_NAME=MyApp
+NEXT_PUBLIC_APP_LOGS_NAME=MiApp
 NEXT_PUBLIC_LOGS_LEVEL=debug
 NEXT_PUBLIC_SILENT_LOGS=false
 ```
 
 #### Encoder
 
-Codificación/decodificación de datos en Base64.
+Codificación/decodificación Base64 para datos de API.
 
 ```typescript
-import { Encoder } from "@mp-front/common/helpers"
+import { Encoder } from '@mp-front/common/helpers'
 
 const encoder = new Encoder()
 
-// Codificar
-const encoded = encoder.encode({ name: "John" }, "request-id-123")
-// Resultado: { info: "base64...", requestID: "request-id-123" }
+// Codificar datos
+const encoded = encoder.encode({ name: 'Juan' }, 'request-id-123')
+// Resultado: { info: 'base64...', requestID: 'request-id-123' }
 
-// Decodificar
+// Decodificar datos
 const decoded = encoder.decode(encoded)
-// Resultado: { name: 'John' }
+// Resultado: { name: 'Juan' }
 ```
 
 #### Encrypter
 
-Encriptación/desencriptación con node-jose (JWE).
+Encriptación/desencriptación JWE con node-jose.
 
 ```typescript
-import { Encrypter } from "@mp-front/common/helpers"
+import { Encrypter } from '@mp-front/common/helpers'
 
 const encrypter = new Encrypter()
 
-// Encriptar
+// Encriptar datos sensibles
 const encrypted = await encrypter.encrypt({
-  password: "secret123",
-  apiKey: "key-xyz",
+  password: 'secret123',
+  apiKey: 'key-xyz'
 })
 
-// Desencriptar
+// Desencriptar datos
 const decrypted = await encrypter.decrypt(encrypted)
 
-// Verificar si está encriptado
+// Verificar si los datos están encriptados
 const isEncrypted = await encrypter.isEncrypted(someString)
 
-// Generar SHA256
-const sha = encrypter.generateSHA({ userId: "123" })
+// Generar hash SHA256
+const sha = encrypter.generateSHA({ userId: '123' })
 ```
 
----
-
-### 7. Errors Module (`@mp-front/common/errors`)
+### Manejo de Errores
 
 #### ErrorHandler
 
-Gestor global de errores con patrón Singleton.
+Gestión global de errores con patrón Singleton.
 
 ```typescript
-import { ErrorHandler } from "@mp-front/common/errors"
+import { ErrorHandler } from '@mp-front/common/errors'
 
 // Suscribirse a errores globales
-ErrorHandler.getInstance()
-  .getSubject()
-  .subscribe(error => {
-    console.error("Error global:", error)
-
-    // Mostrar notificación
-    showNotification({
-      type: "error",
-      message: error.message,
-      code: error.code,
-    })
+ErrorHandler.getInstance().getSubject().subscribe(error => {
+  console.error('Error global:', error)
+  showNotification({
+    type: 'error',
+    message: error.message,
+    code: error.code
   })
+})
 ```
 
 #### RuntimeError
 
-Clase de error personalizada.
+Clase de error personalizada con seguimiento de peticiones.
 
 ```typescript
-import { RuntimeError, RuntimeErrorCode } from "@mp-front/common/errors"
+import { RuntimeError, RuntimeErrorCode } from '@mp-front/common/errors'
 
-// Lanzar error
-throw new RuntimeError(RuntimeErrorCode.VALIDATION_ERROR, "request-id-123")
+// Lanzar error personalizado
+throw new RuntimeError(RuntimeErrorCode.VALIDATION_ERROR, 'request-id-123')
 
-// En un catch
+// En bloques catch
 try {
   // código
 } catch (error) {
-  throw new RuntimeError("CUSTOM_ERROR", requestId)
+  throw new RuntimeError('CUSTOM_ERROR', requestId)
 }
 ```
 
----
-
-### 8. RxJS Module (`@mp-front/common/rxjs`)
+### Utilidades RxJS
 
 #### LoadingHandler
 
-Gestor global de estado de carga.
+Gestión global del estado de carga.
 
 ```typescript
-import { LoadingHandler } from "@mp-front/common/rxjs"
-
-// Suscribirse al estado de loading
-LoadingHandler.getInstance()
-  .getSubject()
-  .subscribe(isLoading => {
-    if (isLoading) {
-      showSpinner()
-    } else {
-      hideSpinner()
-    }
-  })
+import { LoadingHandler } from '@mp-front/common/rxjs'
 
-// Activar loading manualmente
-LoadingHandler.getInstance().setSubject(true)
+// Suscribirse al estado de carga
+LoadingHandler.getInstance().getSubject().subscribe(isLoading => {
+  if (isLoading) {
+    showSpinner()
+  } else {
+    hideSpinner()
+  }
+})
 
-// Desactivar loading
-LoadingHandler.getInstance().setSubject(false)
+// Controlar carga manualmente
+LoadingHandler.getInstance().setSubject(true)  // Mostrar carga
+LoadingHandler.getInstance().setSubject(false) // Ocultar carga
 ```
 
 **Integración con React:**
-
 ```typescript
 import { useEffect, useState } from 'react'
 import { LoadingHandler } from '@mp-front/common/rxjs'
@@ -612,93 +388,98 @@ function App() {
 }
 ```
 
----
-
-### 9. Middleware Module (`@mp-front/common/middleware`)
+### Middleware
 
 #### ApiMiddleware
 
-Middleware para APIs de Next.js con manejo de sesión.
+Middleware de API para Next.js con codificación/decodificación automática.
 
-**Características:**
+```typescript
+import { ApiMiddleware } from '@mp-front/common/middleware'
+import { of } from 'rxjs'
 
-- Encoding/Decoding automático
-- Manejo de errores
-- Logging de requests
-- Soporte para archivos
+interface CreateUserRequest {
+  name: string
+  email: string
+}
 
-**Uso básico:**
+interface CreateUserResponse {
+  id: string
+  name: string
+  email: string
+}
 
-```typescript
-import { ApiMiddleware } from "@mp-front/common/middleware"
+class UserApiMiddleware extends ApiMiddleware {
+  createUser = this.get<CreateUserRequest, CreateUserResponse>(
+    (params, { requestID, headers }) => {
+      // Validación
+      if (!params.name || !params.email) {
+        throw new RuntimeError('VALIDATION_ERROR', requestID)
+      }
 
-class MyApiMiddleware extends ApiMiddleware {
-  constructor() {
-    super()
-  }
-}
+      // Obtener sesión
+      const session = this.getSession()
 
-const middleware = new MyApiMiddleware()
+      // Lógica de negocio
+      const newUser = {
+        id: generateId(),
+        name: params.name,
+        email: params.email
+      }
 
-// Configurar sesión
-middleware.setSession(session)
+      return of(newUser)
+    }
+  )
+}
+
+export const POST = new UserApiMiddleware().createUser
+```
 
-// Handler para GET/POST
-export const POST = middleware.get<RequestType, ResponseType>(
-  (params, { requestID, headers }) => {
-    // Lógica de negocio
+**Manejador de Subida de Archivos:**
+```typescript
+export const POST = middleware.getFormData<ResponseType>(
+  (params, files) => {
+    // Procesar archivos
     return of({
-      success: true,
-      data: processedData,
+      uploadedFiles: files.map(f => ({
+        name: f.name,
+        size: f.size
+      }))
     })
   }
 )
 ```
 
-**Handler para archivos:**
-
-```typescript
-export const POST = middleware.getFile<ResponseType>(file => {
-  // Procesar archivo
-  return of({
-    filename: file.name,
-    size: file.size,
-  })
-})
-```
-
----
-
-### 10. Adapters Module (`@mp-front/common/adapters`)
+### Adaptadores
 
 #### IORedisAdapter
 
-Adaptador de Redis para NextAuth.
+Adaptador NextAuth para Redis.
 
 ```typescript
-import { IORedisAdapter } from "@mp-front/common/adapters"
+import { IORedisAdapter } from '@mp-front/common/adapters'
 
 export const authOptions = {
   adapter: IORedisAdapter({
-    expire: 3600, // segundos
+    expire: 3600 // segundos
   }),
-  // ... otras opciones
+  // ... otras opciones de NextAuth
 }
 ```
 
----
-
-## ⚙️ Configuración Completa
+## Configuración
 
 ### Variables de Entorno
 
+Crea un archivo `.env.local` con las siguientes variables:
+
 ```env
 # Logging
-NEXT_PUBLIC_APP_LOGS_NAME=MyApp
+NEXT_PUBLIC_APP_LOGS_NAME=MiApp
 NEXT_PUBLIC_LOGS_LEVEL=debug
 NEXT_PUBLIC_SILENT_LOGS=false
 
-# Authentication Backend
+# Backend de Autenticación
 API_AUTH_BACK_URL=https://api.example.com/auth
 API_AUTH_BACK_USERNAME_AUTH=username
 API_AUTH_BACK_PASSWORD_AUTH=password
@@ -714,20 +495,19 @@ REDIS_URL=redis://localhost:6379
 TIMEOUT_SESSION_MINUTES=60
 PREFIX_LOGIN=app
 
-# Encryption
-SECRET_SIGNATURE=your-secret-key-min-32-chars
+# Encriptación
+SECRET_SIGNATURE=tu-clave-secreta-min-32-chars
 ```
 
----
+## Ejemplos
 
-## 🚀 Casos de Uso Avanzados
-
-### 1. Sistema de Autenticación Completo
+### Sistema de Autenticación Completo
 
 ```typescript
-import { AuthorizationService } from "@mp-front/common/auth"
-import { HttpClient } from "@mp-front/common/http"
-import { SessionCache } from "@mp-front/common/cache"
+import { AuthorizationService } from '@mp-front/common/auth'
+import { HttpClient } from '@mp-front/common/http'
+import { SessionCache } from '@mp-front/common/cache'
+import { firstValueFrom } from 'rxjs'
 
 class AuthSystem {
   private authService = new AuthorizationService()
@@ -742,29 +522,23 @@ class AuthSystem {
     this.sessionCache = new SessionCache(userId)
     const session = await this.sessionCache.getBasicSession()
 
-    // Hacer request autenticado
-    this.httpClient
-      .get("/api/protected", {
-        headers: {
-          Authorization: `Bearer ${token}`,
-        },
-      })
-      .subscribe(data => {
-        console.log("Datos protegidos:", data)
-      })
+    // Hacer petición autenticada
+    this.httpClient.get('/api/protected', {
+      headers: { Authorization: `Bearer ${token}` }
+    }).subscribe(data => {
+      console.log('Datos protegidos:', data)
+    })
   }
 }
 ```
 
-### 2. Sistema de Caché Multinivel
+### Sistema de Caché Multi-nivel
 
 ```typescript
-import { RedisCache } from "@mp-front/common/cache-providers"
-import { Encrypter } from "@mp-front/common/helpers"
+import { RedisCache } from '@mp-front/common/cache-providers'
 
 class CacheSystem<T> {
   private redis = new RedisCache<T>()
-  private encrypter = new Encrypter()
   private memoryCache = new Map<string, T>()
 
   async get(key: string): Promise<T | null> {
@@ -775,7 +549,7 @@ class CacheSystem<T> {
 
     // Nivel 2: Redis
     try {
-      const { data } = await this.redis.get<T>(key, "data")
+      const { data } = await this.redis.get<T>(key, 'data')
       this.memoryCache.set(key, data)
       return data
     } catch {
@@ -784,129 +558,62 @@ class CacheSystem<T> {
   }
 
   async set(key: string, value: T, ttl: number = 3600) {
-    // Guardar en memoria
     this.memoryCache.set(key, value)
-
-    // Guardar en Redis
+    
     await this.redis.set({
       prefix: key,
-      idData: "data",
+      idData: 'data',
       body: value,
       expire: ttl,
-      encrypted: true,
+      encrypted: true
     })
   }
 }
 ```
 
-### 3. Sistema de Manejo de Errores Global
+### Sistema Global de Errores
 
 ```typescript
-import { ErrorHandler, RuntimeError } from "@mp-front/common/errors"
-import { LoadingHandler } from "@mp-front/common/rxjs"
+import { ErrorHandler, RuntimeError } from '@mp-front/common/errors'
+import { LoadingHandler } from '@mp-front/common/rxjs'
 
 class GlobalErrorSystem {
   constructor() {
     this.setupErrorHandling()
-    this.setupLoadingHandling()
   }
 
   private setupErrorHandling() {
-    ErrorHandler.getInstance()
-      .getSubject()
-      .subscribe(error => {
-        // Ocultar loading
-        LoadingHandler.getInstance().setSubject(false)
-
-        // Log error
-        console.error("Error:", error)
+    ErrorHandler.getInstance().getSubject().subscribe(error => {
+      // Ocultar carga
+      LoadingHandler.getInstance().setSubject(false)
 
-        // Mostrar notificación
-        this.showErrorNotification(error)
+      // Registrar error
+      console.error('Error:', error)
 
-        // Enviar a servicio de tracking
-        this.trackError(error)
-      })
-  }
-
-  private setupLoadingHandling() {
-    LoadingHandler.getInstance()
-      .getSubject()
-      .subscribe(isLoading => {
-        document.body.classList.toggle("loading", isLoading)
-      })
+      // Mostrar notificación
+      this.showErrorNotification(error)
+    })
   }
 
   private showErrorNotification(error: RuntimeError) {
-    // Implementación de notificación
-  }
-
-  private trackError(error: RuntimeError) {
-    // Enviar a Sentry, DataDog, etc.
+    // La implementación depende de tu sistema de notificaciones
   }
 }
 ```
 
-### 4. API Middleware con Validación
-
-```typescript
-import { ApiMiddleware } from "@mp-front/common/middleware"
-import { RuntimeError } from "@mp-front/common/errors"
-import { of, throwError } from "rxjs"
-
-interface CreateUserRequest {
-  name: string
-  email: string
-}
-
-interface CreateUserResponse {
-  id: string
-  name: string
-  email: string
-}
-
-class UserApiMiddleware extends ApiMiddleware {
-  createUser = this.get<CreateUserRequest, CreateUserResponse>(
-    (params, { requestID }) => {
-      // Validación
-      if (!params.name || !params.email) {
-        throw new RuntimeError("VALIDATION_ERROR", requestID)
-      }
-
-      // Obtener sesión
-      const session = this.getSession()
-
-      // Lógica de negocio
-      const newUser = {
-        id: generateId(),
-        name: params.name,
-        email: params.email,
-      }
-
-      return of(newUser)
-    }
-  )
-}
-
-export const POST = new UserApiMiddleware().createUser
-```
-
----
+## Mejores Prácticas
 
-## 📝 Mejores Prácticas
-
-### 1. Manejo de Suscripciones RxJS
+### Gestión de Suscripciones RxJS
 
 ```typescript
-import { Component, OnDestroy } from "@angular/core"
-import { Subject, takeUntil } from "rxjs"
+import { Component, OnDestroy } from '@angular/core'
+import { Subject, takeUntil } from 'rxjs'
 
 class MyComponent implements OnDestroy {
   private destroy$ = new Subject<void>()
 
   ngOnInit() {
-    this.httpClient
-      .get("/api/data")
+    this.httpClient.get('/api/data')
       .pipe(takeUntil(this.destroy$))
       .subscribe(data => {
         // Procesar datos
@@ -920,7 +627,7 @@ class MyComponent implements OnDestroy {
 }
 ```
 
-### 2. Tipado Estricto
+### Seguridad de Tipos
 
 ```typescript
 // Definir interfaces
@@ -934,22 +641,21 @@ interface User {
 const redis = new RedisCache<User>()
 const client = new HttpClient()
 
-client.get<User>("/api/user/1").subscribe(user => {
+client.get<User>('/api/user/1').subscribe(user => {
   // TypeScript sabe que user es de tipo User
   console.log(user.name)
 })
 ```
 
-### 3. Manejo de Errores
+### Manejo de Errores
 
 ```typescript
-import { catchError, of } from "rxjs"
+import { catchError, of } from 'rxjs'
 
-client
-  .get<Data>("/api/data")
+client.get<Data>('/api/data')
   .pipe(
     catchError(error => {
-      console.error("Error:", error)
+      console.error('Error:', error)
       return of(null) // Valor por defecto
     })
   )
@@ -960,47 +666,50 @@ client
   })
 ```
 
----
-
-## 🔧 Troubleshooting
+## Solución de Problemas
 
-### Problema: Redis no conecta
-
-**Solución:**
+### Problemas de Conexión Redis
 
 ```typescript
-import { RedisCache } from "@mp-front/common/cache-providers"
+import { RedisCache } from '@mp-front/common/cache-providers'
 
 const redis = new RedisCache()
 
-redis
-  .statusHost()
-  .then(() => {
-    console.log("Redis conectado")
-  })
-  .catch(error => {
-    console.error("Error de conexión:", error)
-  })
+redis.statusHost()
+  .then(() => console.log('Redis conectado'))
+  .catch(error => console.error('Error de conexión:', error))
 ```
 
-### Problema: Logs no aparecen
-
-**Verificar:**
+### Los Logs No Aparecen
 
+Verifica estas variables de entorno:
 1. `NEXT_PUBLIC_SILENT_LOGS=false`
 2. `NEXT_PUBLIC_LOGS_LEVEL` está configurado correctamente
-3. El nivel del log es mayor o igual al configurado
+3. El nivel de log es apropiado para tus mensajes
 
-### Problema: Encriptación falla
-
-**Verificar:**
+### Fallas de Encriptación
 
+Verifica:
 1. `SECRET_SIGNATURE` está definido en `.env`
 2. La clave tiene al menos 32 caracteres
-3. La clave es la misma para encriptar y desencriptar
+3. Se usa la misma clave para operaciones de encriptar/desencriptar
+
+## Guía de Migración
+
+### De v0.0.1 a v0.0.2
+
+- Actualiza las rutas de importación para usar importaciones modulares
+- Reemplaza métodos deprecados con la nueva API
+- Actualiza nombres de variables de entorno
+
+## Contribuir
 
----
+1. Haz fork del repositorio
+2. Crea una rama de feature
+3. Realiza tus cambios
+4. Agrega pruebas
+5. Envía un pull request
 
-## 📄 Licencia
+## Licencia
 
-Privada - Uso interno únicamente
+Privado - Solo uso interno