@signaltree/events 7.3.6 → 7.4.0

package/{angular.esm.js → dist/angular/websocket.service.js}

@@ -354,194 +354,4 @@ let WebSocketService = class WebSocketService {
 };
 WebSocketService = __decorate([Injectable(), __metadata("design:paramtypes", [Object])], WebSocketService);
 
-/**
- * Optimistic Update Manager
- *
- * Tracks optimistic updates and handles confirmation/rollback.
- *
- * @example
- * ```typescript
- * const manager = new OptimisticUpdateManager();
- *
- * // Apply optimistic update
- * manager.apply({
- *   id: 'update-1',
- *   correlationId: 'corr-123',
- *   type: 'UpdateTradeStatus',
- *   data: { status: 'accepted' },
- *   previousData: { status: 'pending' },
- *   timeoutMs: 5000,
- *   rollback: () => store.$.trade.status.set('pending'),
- * });
- *
- * // When server confirms
- * manager.confirm('corr-123');
- *
- * // Or when server rejects
- * manager.rollback('corr-123', new Error('Server rejected'));
- * ```
- */
-class OptimisticUpdateManager {
-  _updates = signal(new Map());
-  timeouts = new Map();
-  /**
-   * Number of pending updates
-   */
-  pendingCount = computed(() => this._updates().size);
-  /**
-   * Whether there are any pending updates
-   */
-  hasPending = computed(() => this._updates().size > 0);
-  /**
-   * Get all pending updates
-   */
-  pending = computed(() => Array.from(this._updates().values()));
-  /**
-   * Apply an optimistic update
-   */
-  apply(update) {
-    // Store the update
-    this._updates.update(map => {
-      const newMap = new Map(map);
-      newMap.set(update.correlationId, update);
-      return newMap;
-    });
-    // Set timeout for automatic rollback
-    const timeout = setTimeout(() => {
-      this.rollback(update.correlationId, new Error(`Optimistic update timeout after ${update.timeoutMs}ms`));
-    }, update.timeoutMs);
-    this.timeouts.set(update.correlationId, timeout);
-  }
-  /**
-   * Confirm an optimistic update (server accepted)
-   */
-  confirm(correlationId) {
-    const update = this._updates().get(correlationId);
-    if (!update) {
-      return false;
-    }
-    // Clear timeout
-    const timeout = this.timeouts.get(correlationId);
-    if (timeout) {
-      clearTimeout(timeout);
-      this.timeouts.delete(correlationId);
-    }
-    // Remove from pending
-    this._updates.update(map => {
-      const newMap = new Map(map);
-      newMap.delete(correlationId);
-      return newMap;
-    });
-    return true;
-  }
-  /**
-   * Rollback an optimistic update (server rejected or timeout)
-   */
-  rollback(correlationId, error) {
-    const update = this._updates().get(correlationId);
-    if (!update) {
-      return false;
-    }
-    // Clear timeout
-    const timeout = this.timeouts.get(correlationId);
-    if (timeout) {
-      clearTimeout(timeout);
-      this.timeouts.delete(correlationId);
-    }
-    // Execute rollback
-    try {
-      update.rollback();
-    } catch (rollbackError) {
-      console.error('Rollback failed:', rollbackError);
-    }
-    // Remove from pending
-    this._updates.update(map => {
-      const newMap = new Map(map);
-      newMap.delete(correlationId);
-      return newMap;
-    });
-    if (error) {
-      console.warn(`Optimistic update rolled back: ${error.message}`);
-    }
-    return true;
-  }
-  /**
-   * Rollback all pending updates
-   */
-  rollbackAll(error) {
-    const updates = Array.from(this._updates().keys());
-    let count = 0;
-    for (const correlationId of updates) {
-      if (this.rollback(correlationId, error)) {
-        count++;
-      }
-    }
-    return count;
-  }
-  /**
-   * Get update by correlation ID
-   */
-  get(correlationId) {
-    return this._updates().get(correlationId);
-  }
-  /**
-   * Check if an update is pending
-   */
-  isPending(correlationId) {
-    return this._updates().has(correlationId);
-  }
-  /**
-   * Clear all updates without rollback (use with caution)
-   */
-  clear() {
-    // Clear all timeouts
-    for (const timeout of this.timeouts.values()) {
-      clearTimeout(timeout);
-    }
-    this.timeouts.clear();
-    // Clear updates
-    this._updates.set(new Map());
-  }
-  /**
-   * Dispose the manager
-   */
-  dispose() {
-    this.clear();
-  }
-}
-
-/**
- * Create a simple event handler
- *
- * @example
- * ```typescript
- * const handler = createEventHandler<TradeProposalCreated>(event => {
- *   store.$.trades.entities.upsertOne(event.data);
- * });
- * ```
- */
-function createEventHandler(handler) {
-  return handler;
-}
-/**
- * Create a typed event handler with metadata
- *
- * @example
- * ```typescript
- * const handler = createTypedHandler('TradeProposalCreated', {
- *   handle: (event) => {
- *     store.$.trades.entities.upsertOne(event.data);
- *   },
- *   priority: 1,
- * });
- * ```
- */
-function createTypedHandler(eventType, options) {
-  return {
-    eventType,
-    handle: options.handle,
-    priority: options.priority ?? 10
-  };
-}
-
-export { OptimisticUpdateManager, WebSocketService, createEventHandler, createTypedHandler };
+export { WebSocketService };

package/dist/core/error-classification.cjs

@@ -0,0 +1,282 @@
+'use strict';
+
+/**
+ * Error Classification - Determine retry behavior for errors
+ *
+ * Provides:
+ * - Retryable vs non-retryable error classification
+ * - Error categories (transient, permanent, poison)
+ * - Retry configuration per error type
+ * - Custom error classifiers
+ */
+/**
+ * Default retry configurations by classification
+ */
+const DEFAULT_RETRY_CONFIGS = {
+  transient: {
+    maxAttempts: 5,
+    initialDelayMs: 1000,
+    maxDelayMs: 60000,
+    backoffMultiplier: 2,
+    jitter: 0.1
+  },
+  permanent: {
+    maxAttempts: 0,
+    initialDelayMs: 0,
+    maxDelayMs: 0,
+    backoffMultiplier: 1,
+    jitter: 0
+  },
+  poison: {
+    maxAttempts: 0,
+    initialDelayMs: 0,
+    maxDelayMs: 0,
+    backoffMultiplier: 1,
+    jitter: 0
+  },
+  unknown: {
+    maxAttempts: 3,
+    initialDelayMs: 2000,
+    maxDelayMs: 30000,
+    backoffMultiplier: 2,
+    jitter: 0.2
+  }
+};
+/**
+ * Known transient error patterns
+ */
+const TRANSIENT_ERROR_PATTERNS = [
+// Network errors
+/ECONNREFUSED/i, /ECONNRESET/i, /ETIMEDOUT/i, /ENETUNREACH/i, /EHOSTUNREACH/i, /ENOTFOUND/i, /socket hang up/i, /network error/i, /connection.*timeout/i, /request.*timeout/i,
+// Database transient
+/deadlock/i, /lock wait timeout/i, /too many connections/i, /connection pool exhausted/i, /temporarily unavailable/i,
+// HTTP transient
+/502 bad gateway/i, /503 service unavailable/i, /504 gateway timeout/i, /429 too many requests/i,
+// Redis/Queue transient
+/BUSY/i, /LOADING/i, /CLUSTERDOWN/i, /READONLY/i,
+// Generic transient
+/temporary failure/i, /try again/i, /retry/i, /throttl/i, /rate limit/i, /circuit breaker/i];
+/**
+ * Known permanent error patterns
+ */
+const PERMANENT_ERROR_PATTERNS = [
+// Auth errors
+/unauthorized/i, /forbidden/i, /access denied/i, /permission denied/i, /invalid token/i, /token expired/i,
+// Business logic
+/not found/i, /already exists/i, /duplicate/i, /conflict/i, /invalid state/i, /precondition failed/i,
+// HTTP permanent
+/400 bad request/i, /401 unauthorized/i, /403 forbidden/i, /404 not found/i, /409 conflict/i, /422 unprocessable/i];
+/**
+ * Known poison error patterns (send to DLQ immediately)
+ */
+const POISON_ERROR_PATTERNS = [
+// Schema/Serialization
+/invalid json/i, /json parse error/i, /unexpected token/i, /schema validation/i, /invalid event schema/i, /deserialization/i, /malformed/i,
+// Data corruption
+/data corruption/i, /checksum mismatch/i, /integrity error/i];
+/**
+ * Error codes that indicate transient failures
+ */
+const TRANSIENT_ERROR_CODES = new Set(['ECONNREFUSED', 'ECONNRESET', 'ETIMEDOUT', 'ENETUNREACH', 'EHOSTUNREACH', 'ENOTFOUND', 'EPIPE', 'EAI_AGAIN']);
+/**
+ * HTTP status codes that indicate transient failures
+ */
+const TRANSIENT_HTTP_STATUS = new Set([408, 429, 500, 502, 503, 504]);
+/**
+ * HTTP status codes that indicate permanent failures
+ */
+const PERMANENT_HTTP_STATUS = new Set([400, 401, 403, 404, 405, 409, 410, 422]);
+/**
+ * Create an error classifier
+ *
+ * @example
+ * ```typescript
+ * const classifier = createErrorClassifier({
+ *   customClassifiers: [
+ *     (error) => {
+ *       if (error instanceof MyCustomTransientError) return 'transient';
+ *       return null; // Let default classification handle it
+ *     }
+ *   ],
+ *   retryConfigs: {
+ *     transient: { maxAttempts: 10 }, // Override max attempts
+ *   },
+ * });
+ *
+ * const result = classifier.classify(error);
+ * if (result.sendToDlq) {
+ *   await dlqService.send(event, error, result.reason);
+ * }
+ * ```
+ */
+function createErrorClassifier(config = {}) {
+  const customClassifiers = config.customClassifiers ?? [];
+  const defaultClassification = config.defaultClassification ?? 'unknown';
+  // Merge retry configs
+  const retryConfigs = {
+    transient: {
+      ...DEFAULT_RETRY_CONFIGS.transient,
+      ...config.retryConfigs?.transient
+    },
+    permanent: {
+      ...DEFAULT_RETRY_CONFIGS.permanent,
+      ...config.retryConfigs?.permanent
+    },
+    poison: {
+      ...DEFAULT_RETRY_CONFIGS.poison,
+      ...config.retryConfigs?.poison
+    },
+    unknown: {
+      ...DEFAULT_RETRY_CONFIGS.unknown,
+      ...config.retryConfigs?.unknown
+    }
+  };
+  function extractErrorInfo(error) {
+    if (error instanceof Error) {
+      const errWithCode = error;
+      return {
+        message: error.message,
+        name: error.name,
+        code: errWithCode.code,
+        status: errWithCode.status ?? errWithCode.statusCode ?? errWithCode.response?.status
+      };
+    }
+    if (typeof error === 'object' && error !== null) {
+      const obj = error;
+      return {
+        message: String(obj['message'] ?? obj['error'] ?? ''),
+        code: obj['code'],
+        status: obj['status'] ?? obj['statusCode']
+      };
+    }
+    return {
+      message: String(error)
+    };
+  }
+  function classifyByPatterns(message) {
+    // Check poison patterns first (most specific)
+    for (const pattern of POISON_ERROR_PATTERNS) {
+      if (pattern.test(message)) {
+        return 'poison';
+      }
+    }
+    // Check permanent patterns
+    for (const pattern of PERMANENT_ERROR_PATTERNS) {
+      if (pattern.test(message)) {
+        return 'permanent';
+      }
+    }
+    // Check transient patterns
+    for (const pattern of TRANSIENT_ERROR_PATTERNS) {
+      if (pattern.test(message)) {
+        return 'transient';
+      }
+    }
+    return null;
+  }
+  function classify(error) {
+    // 1. Try custom classifiers first
+    for (const classifier of customClassifiers) {
+      const result = classifier(error);
+      if (result !== null) {
+        return {
+          classification: result,
+          retryConfig: retryConfigs[result],
+          sendToDlq: result === 'poison' || result === 'permanent',
+          reason: `Custom classifier: ${result}`
+        };
+      }
+    }
+    const {
+      message,
+      code,
+      status,
+      name
+    } = extractErrorInfo(error);
+    // 2. Check error code
+    if (code && TRANSIENT_ERROR_CODES.has(code)) {
+      return {
+        classification: 'transient',
+        retryConfig: retryConfigs.transient,
+        sendToDlq: false,
+        reason: `Error code: ${code}`
+      };
+    }
+    // 3. Check HTTP status
+    if (status !== undefined) {
+      if (TRANSIENT_HTTP_STATUS.has(status)) {
+        return {
+          classification: 'transient',
+          retryConfig: retryConfigs.transient,
+          sendToDlq: false,
+          reason: `HTTP status: ${status}`
+        };
+      }
+      if (PERMANENT_HTTP_STATUS.has(status)) {
+        return {
+          classification: 'permanent',
+          retryConfig: retryConfigs.permanent,
+          sendToDlq: true,
+          reason: `HTTP status: ${status}`
+        };
+      }
+    }
+    // 4. Check error patterns
+    const patternResult = classifyByPatterns(message) ?? classifyByPatterns(name ?? '');
+    if (patternResult) {
+      return {
+        classification: patternResult,
+        retryConfig: retryConfigs[patternResult],
+        sendToDlq: patternResult === 'poison' || patternResult === 'permanent',
+        reason: `Pattern match: ${message.slice(0, 50)}`
+      };
+    }
+    // 5. Use default classification
+    return {
+      classification: defaultClassification,
+      retryConfig: retryConfigs[defaultClassification],
+      sendToDlq: defaultClassification === 'poison' || defaultClassification === 'permanent',
+      reason: 'No matching pattern, using default'
+    };
+  }
+  function isRetryable(error) {
+    const result = classify(error);
+    return result.classification === 'transient' || result.classification === 'unknown';
+  }
+  function calculateDelay(attempt, retryConfig) {
+    // Exponential backoff: initialDelay * multiplier^attempt
+    const baseDelay = retryConfig.initialDelayMs * Math.pow(retryConfig.backoffMultiplier, attempt);
+    // Cap at maxDelay
+    const cappedDelay = Math.min(baseDelay, retryConfig.maxDelayMs);
+    // Add jitter to prevent thundering herd
+    const jitter = cappedDelay * retryConfig.jitter * Math.random();
+    return Math.round(cappedDelay + jitter);
+  }
+  return {
+    classify,
+    isRetryable,
+    calculateDelay
+  };
+}
+/**
+ * Pre-configured error classifier instance
+ */
+const defaultErrorClassifier = createErrorClassifier();
+/**
+ * Quick helper to check if error is retryable
+ */
+function isRetryableError(error) {
+  return defaultErrorClassifier.isRetryable(error);
+}
+/**
+ * Quick helper to classify error
+ */
+function classifyError(error) {
+  return defaultErrorClassifier.classify(error);
+}
+
+exports.DEFAULT_RETRY_CONFIGS = DEFAULT_RETRY_CONFIGS;
+exports.classifyError = classifyError;
+exports.createErrorClassifier = createErrorClassifier;
+exports.defaultErrorClassifier = defaultErrorClassifier;
+exports.isRetryableError = isRetryableError;