@evolith/core-domain 1.0.0 → 1.0.1

package/rulesets/topologies/edge-computing/patterns.es.md

@@ -0,0 +1,291 @@
+# Guía de Patrones de Computación en el Borde
+
+> **Navegación Bilingüe:** [English](./patterns.md) | [Español](./patterns.es.md)
+
+**Propietario:** Ingeniería de Plataforma
+**Topología:** Computación en el Borde
+
+## Funciones del Borde
+
+Las funciones del borde ejecutan código del lado del servidor más cercano al cliente, reduciendo la latencia y mejorando la experiencia del usuario.
+
+### Ciclo de Vida de la Función
+
+```
+Solicitud → Enrutador de Funciones → Función del Borde → Respuesta
+                         ↓
+                    Inicio en Frío (si es necesario)
+                         ↓
+                    Inicializar Runtime
+                         ↓
+                    Ejecutar Handler
+                         ↓
+                    Devolver Respuesta
+```
+
+### Plantillas de Funciones
+
+```javascript
+// Función básica del borde
+export default async function handler(request) {
+  const { url, method, headers } = request;
+  
+  // Procesar en el borde
+  const response = await processRequest(request);
+  
+  return new Response(response.body, {
+    status: 200,
+    headers: {
+      'Content-Type': 'application/json',
+      'X-Edge-Location': process.env.EDGE_LOCATION,
+      'X-Edge-Node': process.env.EDGE_NODE_ID
+    }
+  });
+}
+```
+
+### Optimización de Inicio en Frío
+
+| Estrategia | Tiempo de Inicio en Frío | Caso de Uso |
+|------------|-------------------------|-------------|
+| Instancias pre-calentadas | < 50ms | Funciones de alto tráfico |
+| Restauración de instantánea | < 100ms | Funciones de tráfico medio |
+| Inicialización lazy | 200-500ms | Funciones de bajo tráfico |
+| Dependencias empaquetadas | < 100ms | Todas las funciones |
+
+## Integración CDN
+
+La computación en el borde extiende las capacidades CDN tradicionales con procesamiento de contenido dinámico.
+
+### Arquitectura CDN + Borde
+
+```
+┌─────────────────────────────────────────────────┐
+│  Capa de Borde CDN                              │
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────┐ │
+│  │ Caché       │  │ Cómputo del │  │Almacenam.│ │
+│  │ Estático    │  │ Borde       │  │ del Borde│ │
+│  │ (Activos)   │  │ (Funciones) │  │         │ │
+│  └─────────────┘  └─────────────┘  └─────────┘ │
+└─────────────────────────────────────────────────┘
+                         │
+                    ┌────┴────┐
+                    │ Origen  │
+                    └─────────┘
+```
+
+### Integración Caché-Cómputo
+
+```yaml
+cdn_edge:
+  routes:
+    - path: "/static/*"
+      handler: "cache-serve"
+      cache_ttl: 3600s
+    - path: "/api/*"
+      handler: "edge-function"
+      cache_ttl: 0s
+    - path: "/dynamic/*"
+      handler: "edge-compute"
+      cache_ttl: 60s
+      stale_while_revalidate: 30s
+```
+
+## Datos Primero Local
+
+La arquitectura de datos primero local prioriza el almacenamiento local y la sincronización sobre las bases de datos centralizadas.
+
+### Flujo de Datos
+
+```
+Aplicación → Almacén Local → Sincronización en Segundo Plano → Origen
+                ↓ (lectura)
+          Consulta Local (rápida)
+                ↓ (escritura)
+          Escritura Local → Cola → Sincronización
+```
+
+### Patrones de Almacenamiento Local
+
+```javascript
+// Wrapper de IndexedDB para datos primero local
+class LocalFirstDB {
+  constructor(dbName) {
+    this.db = await openDB(dbName, 1, {
+      upgrade(db) {
+        db.createObjectStore('documents', { keyPath: 'id' });
+        db.createObjectStore('sync-queue', { autoIncrement: true });
+      }
+    });
+  }
+  
+  async read(id) {
+    // Leer del almacén local primero
+    const local = await this.db.get('documents', id);
+    if (local) return local;
+    
+    // Conmutar a la red si no está en el almacén local
+    const remote = await fetchFromOrigin(id);
+    await this.db.put('documents', remote);
+    return remote;
+  }
+  
+  async write(data) {
+    // Escribir localmente primero
+    await this.db.put('documents', data);
+    
+    // Encolar para sincronización
+    await this.db.add('sync-queue', {
+      type: 'write',
+      data,
+      timestamp: Date.now()
+    });
+  }
+}
+```
+
+## Service Workers
+
+Los service workers habilitan capacidades sin conexión y procesamiento en segundo plano en el borde.
+
+### Arquitectura de Service Worker
+
+```
+┌─────────────────────────────────────────────┐
+│  Navegador / Runtime del Borde              │
+│  ┌─────────────────────────────────────┐   │
+│  │  Service Worker                     │   │
+│  │  - Intercepción de solicitudes      │   │
+│  │  - Gestión de caché                 │   │
+│  │  - Sincronización en segundo plano  │   │
+│  │  - Notificaciones push              │   │
+│  └─────────────────────────────────────┘   │
+└─────────────────────────────────────────────┘
+```
+
+### Registro de Service Worker
+
+```javascript
+// Registrar service worker
+if ('serviceWorker' in navigator) {
+  navigator.serviceWorker.register('/sw.js', {
+    scope: '/',
+    type: 'module'
+  });
+}
+
+// sw.js
+self.addEventListener('fetch', (event) => {
+  event.respondWith(
+    caches.match(event.request)
+      .then(response => response || fetch(event.request))
+  );
+});
+```
+
+## Sincronización Write-Behind
+
+La sincronización write-behind reconoce las escrituras localmente y sincroniza asincrónicamente con el origen.
+
+### Arquitectura Write-Behind
+
+```
+Escritura del Cliente → Almacén Local → Reconocer → Sincronización en Segundo Plano → Origen
+                       ↓
+                 Registro WAL
+                       ↓
+                 Detección de Conflictos
+                       ↓
+                 Estrategia de Resolución
+```
+
+### Implementación
+
+```javascript
+class WriteBehindSync {
+  constructor(localDB, syncQueue) {
+    this.localDB = localDB;
+    this.syncQueue = syncQueue;
+  }
+  
+  async write(key, value) {
+    // Escribir en el almacén local
+    await this.localDB.put(key, value);
+    
+    // Agregar al registro WAL
+    const walEntry = await this.localDB.addToWAL({
+      key,
+      value,
+      timestamp: Date.now(),
+      status: 'pending'
+    });
+    
+    // Encolar para sincronización en segundo plano
+    await this.syncQueue.enqueue({
+      type: 'write-behind',
+      walEntryId: walEntry.id,
+      retryCount: 0
+    });
+    
+    return { success: true, walEntryId: walEntry.id };
+  }
+}
+```
+
+## CRDTs (Tipos de Datos Replicados sin Conflictos)
+
+Los CRDTs permiten la resolución automática de conflictos sin coordinación.
+
+### Tipos de CRDT
+
+| Tipo | Operación | Caso de Uso |
+|------|-----------|-------------|
+| G-Counter | Incrementar | Conteos de likes, contadores de vistas |
+| PN-Counter | Incrementar/Decrementar | Saldos, conteos de votos |
+| G-Set | Agregar | Listas de etiquetas, listas de seguidores |
+| OR-Set | Agregar/Eliminar | Carritos de compras, listas de usuarios |
+| LWW-Register | Establecer | Preferencias de usuario |
+| MV-Register | Establecer (multi-valor) | Edición colaborativa |
+
+### Implementación de CRDT
+
+```javascript
+// CRDT G-Counter para conteo distribuido
+class GCounter {
+  constructor(nodeId) {
+    this.nodeId = nodeId;
+    this.counts = new Map();
+  }
+  
+  increment() {
+    const current = this.counts.get(this.nodeId) || 0;
+    this.counts.set(this.nodeId, current + 1);
+  }
+  
+  merge(other) {
+    for (const [node, count] of other.counts) {
+      const current = this.counts.get(node) || 0;
+      this.counts.set(node, Math.max(current, count));
+    }
+  }
+  
+  value() {
+    return Array.from(this.counts.values())
+      .reduce((sum, count) => sum + count, 0);
+  }
+}
+```
+
+### Sincronización de CRDT
+
+```bash
+# Configurar sincronización CRDT para nodos del borde
+edge-cli crdt sync configure \
+  --type g-counter \
+  --sync-interval 5s \
+  --conflict-strategy merge \
+  --nodes "edge-node-01,edge-node-02,edge-node-03"
+```
+
+---
+[Volver al Perfil de Computación en el Borde](./README.es.md)

package/rulesets/topologies/edge-computing/patterns.md

@@ -0,0 +1,290 @@
+# Edge Computing — Patterns Guide
+
+> **Bilingual Navigation:** [English](./patterns.md) | [Español](./patterns.es.md)
+
+**Owner:** Platform Engineering
+**Topology:** Edge Computing
+
+## Edge Functions
+
+Edge functions execute server-side code closest to the client, reducing latency and improving user experience.
+
+### Function Lifecycle
+
+```
+Request → Function Router → Edge Function → Response
+                         ↓
+                    Cold Start (if needed)
+                         ↓
+                    Initialize Runtime
+                         ↓
+                    Execute Handler
+                         ↓
+                    Return Response
+```
+
+### Function Templates
+
+```javascript
+// Basic edge function
+export default async function handler(request) {
+  const { url, method, headers } = request;
+  
+  // Process at the edge
+  const response = await processRequest(request);
+  
+  return new Response(response.body, {
+    status: 200,
+    headers: {
+      'Content-Type': 'application/json',
+      'X-Edge-Location': process.env.EDGE_LOCATION,
+      'X-Edge-Node': process.env.EDGE_NODE_ID
+    }
+  });
+}
+```
+
+### Cold Start Optimization
+
+| Strategy | Cold Start Time | Use Case |
+|----------|-----------------|----------|
+| Pre-warmed instances | < 50ms | High-traffic functions |
+| Snapshot restore | < 100ms | Medium-traffic functions |
+| Lazy initialization | 200-500ms | Low-traffic functions |
+| Bundled dependencies | < 100ms | All functions |
+
+## CDN Integration
+
+Edge computing extends traditional CDN capabilities with dynamic content processing.
+
+### CDN + Edge Architecture
+
+```
+┌─────────────────────────────────────────────────┐
+│  CDN Edge Layer                                 │
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────┐ │
+│  │ Static Cache│  │ Edge Compute│  │ Edge    │ │
+│  │ (Assets)    │  │ (Functions) │  │ Storage │ │
+│  └─────────────┘  └─────────────┘  └─────────┘ │
+└─────────────────────────────────────────────────┘
+                         │
+                    ┌────┴────┐
+                    │ Origin  │
+                    └─────────┘
+```
+
+### Cache-Compute Integration
+
+```yaml
+cdn_edge:
+  routes:
+    - path: "/static/*"
+      handler: "cache-serve"
+      cache_ttl: 3600s
+    - path: "/api/*"
+      handler: "edge-function"
+      cache_ttl: 0s
+    - path: "/dynamic/*"
+      handler: "edge-compute"
+      cache_ttl: 60s
+      stale_while_revalidate: 30s
+```
+
+## Local-First Data
+
+Local-first data architecture prioritizes local storage and synchronization over centralized databases.
+
+### Data Flow
+
+```
+Application → Local Store → Background Sync → Origin
+                ↓ (read)
+          Local Query (fast)
+                ↓ (write)
+          Local Write → Queue → Sync
+```
+
+### Local Storage Patterns
+
+```javascript
+// IndexedDB wrapper for local-first data
+class LocalFirstDB {
+  constructor(dbName) {
+    this.db = await openDB(dbName, 1, {
+      upgrade(db) {
+        db.createObjectStore('documents', { keyPath: 'id' });
+        db.createObjectStore('sync-queue', { autoIncrement: true });
+      }
+    });
+  }
+  
+  async read(id) {
+    // Read from local store first
+    const local = await this.db.get('documents', id);
+    if (local) return local;
+    
+    // Fallback to network if not in local store
+    const remote = await fetchFromOrigin(id);
+    await this.db.put('documents', remote);
+    return remote;
+  }
+  
+  async write(data) {
+    // Write locally first
+    await this.db.put('documents', data);
+    
+    // Queue for sync
+    await this.db.add('sync-queue', {
+      type: 'write',
+      data,
+      timestamp: Date.now()
+    });
+  }
+}
+```
+
+## Service Workers
+
+Service workers enable offline capabilities and background processing at the edge.
+
+### Service Worker Architecture
+
+```
+┌─────────────────────────────────────────────┐
+│  Browser / Edge Runtime                     │
+│  ┌─────────────────────────────────────┐   │
+│  │  Service Worker                     │   │
+│  │  - Request interception             │   │
+│  │  - Cache management                 │   │
+│  │  - Background sync                  │   │
+│  │  - Push notifications               │   │
+│  └─────────────────────────────────────┘   │
+└─────────────────────────────────────────────┘
+```
+
+### Service Worker Registration
+
+```javascript
+// Register service worker
+if ('serviceWorker' in navigator) {
+  navigator.serviceWorker.register('/sw.js', {
+    scope: '/',
+    type: 'module'
+  });
+}
+
+// sw.js
+self.addEventListener('fetch', (event) => {
+  event.respondWith(
+    caches.match(event.request)
+      .then(response => response || fetch(event.request))
+  );
+});
+```
+
+## Write-Behind Sync
+
+Write-behind sync acknowledges writes locally and synchronizes asynchronously to the origin.
+
+### Write-Behind Architecture
+
+```
+Client Write → Local Store → Acknowledge → Background Sync → Origin
+                  ↓
+            Write-Ahead Log
+                  ↓
+            Conflict Detection
+                  ↓
+            Resolution Strategy
+```
+
+### Implementation
+
+```javascript
+class WriteBehindSync {
+  constructor(localDB, syncQueue) {
+    this.localDB = localDB;
+    this.syncQueue = syncQueue;
+  }
+  
+  async write(key, value) {
+    // Write to local store
+    await this.localDB.put(key, value);
+    
+    // Add to write-ahead log
+    const walEntry = await this.localDB.addToWAL({
+      key,
+      value,
+      timestamp: Date.now(),
+      status: 'pending'
+    });
+    
+    // Queue for background sync
+    await this.syncQueue.enqueue({
+      type: 'write-behind',
+      walEntryId: walEntry.id,
+      retryCount: 0
+    });
+    
+    return { success: true, walEntryId: walEntry.id };
+  }
+}
+```
+
+## CRDTs (Conflict-free Replicated Data Types)
+
+CRDTs enable automatic conflict resolution without coordination.
+
+### CRDT Types
+
+| Type | Operation | Use Case |
+|------|-----------|----------|
+| G-Counter | Increment | Like counts, view counters |
+| PN-Counter | Increment/Decrement | Balances, vote counts |
+| G-Set | Add | Tag lists, follower lists |
+| OR-Set | Add/Remove | Shopping carts, user lists |
+| LWW-Register | Set | User preferences |
+| MV-Register | Set (multi-value) | Collaborative editing |
+
+### CRDT Implementation
+
+```javascript
+// G-Counter CRDT for distributed counting
+class GCounter {
+  constructor(nodeId) {
+    this.nodeId = nodeId;
+    this.counts = new Map();
+  }
+  
+  increment() {
+    const current = this.counts.get(this.nodeId) || 0;
+    this.counts.set(this.nodeId, current + 1);
+  }
+  
+  merge(other) {
+    for (const [node, count] of other.counts) {
+      const current = this.counts.get(node) || 0;
+      this.counts.set(node, Math.max(current, count));
+    }
+  }
+  
+  value() {
+    return Array.from(this.counts.values())
+      .reduce((sum, count) => sum + count, 0);
+  }
+}
+```
+
+### CRDT Synchronization
+
+```bash
+# Configure CRDT sync for edge nodes
+edge-cli crdt sync configure \
+  --type g-counter \
+  --sync-interval 5s \
+  --conflict-strategy merge \
+  --nodes "edge-node-01,edge-node-02,edge-node-03"
+```
+
+---
+[Back to Edge Computing Profile](./README.md)