@onlineapps/error-handler-core 1.1.14 → 1.1.16

package/README.md

@@ -105,7 +105,7 @@ const result = await errorHandler.executeWithCircuitBreaker({
 
 ## API Reference
 
-See [UNIFIED_ERROR_HANDLING.md](/docs/standards/UNIFIED_ERROR_HANDLING.md) for complete API documentation.
+See [ERROR_HANDLING.md](/docs/standards/ERROR_HANDLING.md) for the cross-cutting standard (classification table, fail-loudly rules).
 
 ## Architecture
 
@@ -115,8 +115,6 @@ See [UNIFIED_ERROR_HANDLING.md](/docs/standards/UNIFIED_ERROR_HANDLING.md) for c
 
 ## Related Documentation
 
-- [Unified Error Handling Standard](/docs/standards/UNIFIED_ERROR_HANDLING.md)
-- [Error Handling Architecture](/docs/standards/ERROR_HANDLING_ARCHITECTURE.md)
 - [Error Handling Standard](/docs/standards/ERROR_HANDLING.md)
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/error-handler-core",
-  "version": "1.1.14",
+  "version": "1.1.16",
   "description": "Core error handling functionality for OA Drive microservices - classification, retry, circuit breaker, DLQ routing",
   "main": "src/index.js",
   "scripts": {
@@ -20,8 +20,7 @@
   "author": "OnlineApps",
   "license": "MIT",
   "dependencies": {
-    "@onlineapps/monitoring-core": "1.0.25",
-    "@onlineapps/runtime-config": "1.0.2",
+    "@onlineapps/runtime-config": "1.0.3",
     "opossum": "^7.0.0"
   },
   "devDependencies": {

package/jest.config.js

@@ -1,23 +0,0 @@
-module.exports = {
-  testEnvironment: 'node',
-  coveragePathIgnorePatterns: [
-    '/node_modules/',
-    '/tests/'
-  ],
-  testMatch: [
-    '**/tests/**/*.test.js'
-  ],
-  collectCoverageFrom: [
-    'src/**/*.js',
-    '!src/**/*.test.js'
-  ],
-  coverageThreshold: {
-    global: {
-      branches: 70,
-      functions: 70,
-      lines: 70,
-      statements: 70
-    }
-  }
-};
-

package/tests/unit/DLQRouter.test.js

@@ -1,94 +0,0 @@
-/**
- * DLQRouter Unit Tests
- */
-
-const DLQRouter = require('../../src/DLQRouter');
-
-describe('DLQRouter @unit', () => {
-  let dlqRouter;
-  let mockMQClient;
-  
-  beforeEach(() => {
-    mockMQClient = {
-      publish: jest.fn().mockResolvedValue()
-    };
-    
-    dlqRouter = new DLQRouter({
-      dlqEnabled: true,
-      mqClient: mockMQClient,
-      dlqNamePattern: '{queue}.dlq'
-    });
-  });
-  
-  describe('routeToDLQ', () => {
-    test('should route message to DLQ', async () => {
-      const message = { id: 'msg-123', data: 'test' };
-      const error = new Error('Test error');
-      const context = { queue: 'test.queue' };
-      
-      await dlqRouter.routeToDLQ(message, error, 'BUSINESS', context);
-      
-      expect(mockMQClient.publish).toHaveBeenCalledWith(
-        'test.queue.dlq',
-        expect.objectContaining({
-          id: 'msg-123',
-          error: expect.objectContaining({
-            message: 'Test error',
-            type: 'BUSINESS'
-          }),
-          originalQueue: 'test.queue'
-        }),
-        { persistent: true }
-      );
-    });
-    
-    test('should not route if DLQ disabled', async () => {
-      const disabledRouter = new DLQRouter({
-        dlqEnabled: false,
-        mqClient: mockMQClient
-      });
-      
-      await disabledRouter.routeToDLQ({}, new Error('Test'), 'BUSINESS', {});
-      
-      expect(mockMQClient.publish).not.toHaveBeenCalled();
-    });
-    
-    test('should not route if no MQ client', async () => {
-      const noClientRouter = new DLQRouter({
-        dlqEnabled: true,
-        mqClient: null
-      });
-      
-      await noClientRouter.routeToDLQ({}, new Error('Test'), 'BUSINESS', {});
-      
-      expect(mockMQClient.publish).not.toHaveBeenCalled();
-    });
-    
-    test('should handle DLQ routing failure gracefully', async () => {
-      mockMQClient.publish.mockRejectedValue(new Error('DLQ failed'));
-      const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
-      
-      await dlqRouter.routeToDLQ({}, new Error('Test'), 'BUSINESS', { queue: 'test' });
-      
-      expect(consoleSpy).toHaveBeenCalled();
-      consoleSpy.mockRestore();
-    });
-  });
-  
-  describe('isAvailable', () => {
-    test('should return true if enabled and client available', () => {
-      expect(dlqRouter.isAvailable()).toBe(true);
-    });
-    
-    test('should return false if disabled', () => {
-      const disabledRouter = new DLQRouter({ dlqEnabled: false });
-      expect(disabledRouter.isAvailable()).toBe(false);
-    });
-    
-    test('should return false if no client', () => {
-      const noClientRouter = new DLQRouter({ mqClient: null });
-      expect(noClientRouter.isAvailable()).toBe(false);
-    });
-  });
-});
-

package/tests/unit/ErrorClassifier.test.js

@@ -1,82 +0,0 @@
-/**
- * ErrorClassifier Unit Tests
- */
-
-const { ErrorClassifier, ErrorTypes } = require('../../src/ErrorClassifier');
-
-describe('ErrorClassifier @unit', () => {
-  let classifier;
-  
-  beforeEach(() => {
-    classifier = new ErrorClassifier();
-  });
-  
-  describe('classify', () => {
-    test('should classify ECONNREFUSED as TRANSIENT', () => {
-      const error = new Error('Connection refused');
-      error.code = 'ECONNREFUSED';
-      
-      expect(classifier.classify(error)).toBe(ErrorTypes.TRANSIENT);
-    });
-    
-    test('should classify HTTP 404 as BUSINESS', () => {
-      const error = new Error('Not Found');
-      error.statusCode = 404;
-      
-      expect(classifier.classify(error)).toBe(ErrorTypes.BUSINESS);
-    });
-    
-    test('should classify timeout message as TIMEOUT', () => {
-      const error = new Error('Operation timeout');
-      
-      expect(classifier.classify(error)).toBe(ErrorTypes.TIMEOUT);
-    });
-    
-    test('should classify explicit type', () => {
-      const error = new Error('Custom error');
-      error.type = 'BUSINESS';
-      
-      expect(classifier.classify(error)).toBe(ErrorTypes.BUSINESS);
-    });
-    
-    test('should return UNKNOWN for unclassified error', () => {
-      const error = new Error('Some random error');
-      
-      expect(classifier.classify(error)).toBe(ErrorTypes.UNKNOWN);
-    });
-    
-    test('should handle null error', () => {
-      expect(classifier.classify(null)).toBe(ErrorTypes.UNKNOWN);
-    });
-  });
-  
-  describe('shouldRetry', () => {
-    test('should retry TRANSIENT errors', () => {
-      const error = new Error('Connection refused');
-      error.code = 'ECONNREFUSED';
-      
-      expect(classifier.shouldRetry(error, 0, 3)).toBe(true);
-    });
-    
-    test('should not retry after max attempts', () => {
-      const error = new Error('Connection refused');
-      error.code = 'ECONNREFUSED';
-      
-      expect(classifier.shouldRetry(error, 3, 3)).toBe(false);
-    });
-    
-    test('should not retry BUSINESS errors', () => {
-      const error = new Error('Not Found');
-      error.statusCode = 404;
-      
-      expect(classifier.shouldRetry(error, 0, 3)).toBe(false);
-    });
-    
-    test('should retry TIMEOUT errors', () => {
-      const error = new Error('Operation timeout');
-      
-      expect(classifier.shouldRetry(error, 0, 3)).toBe(true);
-    });
-  });
-});
-

package/tests/unit/ErrorHandlerCore.test.js

@@ -1,183 +0,0 @@
-/**
- * ErrorHandlerCore Unit Tests
- */
-
-const ErrorHandlerCore = require('../../src/ErrorHandlerCore');
-const { ErrorTypes } = require('../../src/ErrorClassifier');
-
-describe('ErrorHandlerCore @unit', () => {
-  let errorHandler;
-  let mockMonitoring;
-  
-  beforeEach(() => {
-    mockMonitoring = {
-      logger: {
-        error: jest.fn(),
-        warn: jest.fn(),
-        info: jest.fn()
-      },
-      // Fallback for conn-base-monitoring wrapper
-      error: jest.fn(),
-      warn: jest.fn(),
-      info: jest.fn()
-    };
-    
-    errorHandler = new ErrorHandlerCore({
-      serviceName: 'test-service',
-      serviceVersion: '1.0.0',
-      environment: 'test',
-      monitoring: mockMonitoring,
-      handling: {
-        maxRetries: 3,
-        retryDelay: 100
-      }
-    });
-  });
-  
-  describe('constructor', () => {
-    test('should throw if serviceName missing', () => {
-      expect(() => {
-        new ErrorHandlerCore({
-          monitoring: mockMonitoring
-        });
-      }).toThrow('serviceName is required');
-    });
-    
-    test('should throw if monitoring missing', () => {
-      expect(() => {
-        new ErrorHandlerCore({
-          serviceName: 'test'
-        });
-      }).toThrow('monitoring instance is required');
-    });
-    
-    test('should initialize with valid config', () => {
-      expect(errorHandler.serviceName).toBe('test-service');
-      expect(errorHandler.classifier).toBeDefined();
-      expect(errorHandler.retryHandler).toBeDefined();
-    });
-  });
-  
-  describe('logError', () => {
-    test('should log error via monitoring', async () => {
-      const error = new Error('Test error');
-      
-      const result = await errorHandler.logError({
-        moduleName: 'TestModule',
-        operation: 'testOperation',
-        error: error
-      });
-      
-      expect(mockMonitoring.logger.error).toHaveBeenCalled();
-      expect(result).toHaveProperty('timestamp');
-      expect(result).toHaveProperty('error');
-      expect(result.error.type).toBeDefined();
-    });
-    
-    test('should handle monitoring failure gracefully', async () => {
-      // Mock logger.error to throw
-      mockMonitoring.logger.error.mockImplementation(() => {
-        throw new Error('Monitoring failed');
-      });
-      
-      const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
-      
-      const error = new Error('Test error');
-      await errorHandler.logError({
-        moduleName: 'TestModule',
-        operation: 'testOperation',
-        error: error
-      });
-      
-      expect(consoleSpy).toHaveBeenCalled();
-      consoleSpy.mockRestore();
-    });
-  });
-  
-  describe('handleError', () => {
-    test('should classify and log error', async () => {
-      const error = new Error('Connection refused');
-      error.code = 'ECONNREFUSED';
-      
-      const result = await errorHandler.handleError({
-        moduleName: 'TestModule',
-        operation: 'testOperation',
-        error: error
-      });
-      
-      expect(result.errorType).toBe(ErrorTypes.TRANSIENT);
-      expect(result.action).toBe('retry');
-      expect(result.shouldRetry).toBe(true);
-      expect(mockMonitoring.logger.error).toHaveBeenCalled();
-    });
-    
-    test('should route to DLQ for BUSINESS errors', async () => {
-      const error = new Error('Not Found');
-      error.statusCode = 404;
-      
-      // Mock MQ client for DLQ
-      const mockMQClient = {
-        publish: jest.fn().mockResolvedValue()
-      };
-      
-      errorHandler.dlqRouter.mqClient = mockMQClient;
-      
-      const result = await errorHandler.handleError({
-        moduleName: 'TestModule',
-        operation: 'testOperation',
-        error: error,
-        context: {
-          message: { id: 'msg-123' },
-          queue: 'test.queue'
-        }
-      });
-      
-      expect(result.errorType).toBe(ErrorTypes.BUSINESS);
-      expect(result.action).toBe('dlq');
-      expect(mockMQClient.publish).toHaveBeenCalled();
-    });
-    
-    test('should throw for FATAL errors', async () => {
-      const error = new Error('Fatal error');
-      error.type = 'FATAL';
-      
-      const result = await errorHandler.handleError({
-        moduleName: 'TestModule',
-        operation: 'testOperation',
-        error: error
-      });
-      
-      expect(result.errorType).toBe(ErrorTypes.FATAL);
-      expect(result.action).toBe('throw');
-    });
-  });
-  
-  describe('executeWithRetry', () => {
-    test('should retry on failure', async () => {
-      const fn = jest.fn()
-        .mockRejectedValueOnce(new Error('Fail 1'))
-        .mockResolvedValue('success');
-      
-      const result = await errorHandler.executeWithRetry({
-        moduleName: 'TestModule',
-        operation: 'testOperation',
-        fn: fn
-      });
-      
-      expect(result).toBe('success');
-      expect(fn).toHaveBeenCalledTimes(2);
-      expect(mockMonitoring.logger.error).toHaveBeenCalled(); // Logs retry attempt
-    });
-  });
-  
-  describe('registerCompensation', () => {
-    test('should register compensation handler', () => {
-      const handler = jest.fn().mockResolvedValue();
-      
-      errorHandler.registerCompensation('test-operation', handler);
-      
-      expect(errorHandler.compensation.hasHandler('test-operation')).toBe(true);
-    });
-  });
-});
-

package/tests/unit/RetryHandler.test.js

@@ -1,81 +0,0 @@
-/**
- * RetryHandler Unit Tests
- */
-
-const RetryHandler = require('../../src/RetryHandler');
-
-describe('RetryHandler @unit', () => {
-  let retryHandler;
-  
-  beforeEach(() => {
-    retryHandler = new RetryHandler({
-      maxRetries: 3,
-      retryDelay: 1000,
-      retryMultiplier: 2
-    });
-  });
-  
-  describe('calculateBackoff', () => {
-    test('should calculate exponential backoff', () => {
-      expect(retryHandler.calculateBackoff(1)).toBe(1000);
-      expect(retryHandler.calculateBackoff(2)).toBe(2000);
-      expect(retryHandler.calculateBackoff(3)).toBe(4000);
-      expect(retryHandler.calculateBackoff(4)).toBe(8000);
-    });
-    
-    test('should cap at maxRetryDelay', () => {
-      const handler = new RetryHandler({
-        maxRetryDelay: 5000
-      });
-      
-      expect(handler.calculateBackoff(10)).toBe(5000);
-    });
-  });
-  
-  describe('executeWithRetry', () => {
-    test('should succeed on first attempt', async () => {
-      const fn = jest.fn().mockResolvedValue('success');
-      
-      const result = await retryHandler.executeWithRetry(fn);
-      
-      expect(result).toBe('success');
-      expect(fn).toHaveBeenCalledTimes(1);
-    });
-    
-    test('should retry on failure', async () => {
-      const fn = jest.fn()
-        .mockRejectedValueOnce(new Error('Fail 1'))
-        .mockRejectedValueOnce(new Error('Fail 2'))
-        .mockResolvedValue('success');
-      
-      const result = await retryHandler.executeWithRetry(fn);
-      
-      expect(result).toBe('success');
-      expect(fn).toHaveBeenCalledTimes(3);
-    });
-    
-    test('should throw after max retries', async () => {
-      const error = new Error('Always fails');
-      const fn = jest.fn().mockRejectedValue(error);
-      
-      await expect(retryHandler.executeWithRetry(fn)).rejects.toThrow('Always fails');
-      expect(fn).toHaveBeenCalledTimes(3);
-    });
-    
-    test('should call onRetry callback', async () => {
-      const onRetry = jest.fn();
-      const fn = jest.fn()
-        .mockRejectedValueOnce(new Error('Fail'))
-        .mockResolvedValue('success');
-      
-      await retryHandler.executeWithRetry(fn, { onRetry });
-      
-      expect(onRetry).toHaveBeenCalledWith(
-        expect.any(Error),
-        1,
-        1000
-      );
-    });
-  });
-});
-

package/tests/unit/UnifiedLogSchema.test.js

@@ -1,75 +0,0 @@
-/**
- * UnifiedLogSchema Unit Tests
- */
-
-const UnifiedLogSchema = require('../../src/UnifiedLogSchema');
-
-describe('UnifiedLogSchema @unit', () => {
-  let schema;
-  
-  beforeEach(() => {
-    schema = new UnifiedLogSchema();
-  });
-  
-  describe('create', () => {
-    test('should create unified log entry', () => {
-      const error = new Error('Test error');
-      error.code = 'ETIMEDOUT';
-      
-      const logEntry = schema.create({
-        moduleName: 'TestModule',
-        operation: 'testOperation',
-        error: error,
-        context: { userId: 123 },
-        serviceName: 'test-service',
-        serviceVersion: '1.0.0',
-        environment: 'test',
-        errorType: 'TRANSIENT'
-      });
-      
-      expect(logEntry).toHaveProperty('timestamp');
-      expect(logEntry).toHaveProperty('serviceName', 'test-service');
-      expect(logEntry).toHaveProperty('moduleName', 'TestModule');
-      expect(logEntry).toHaveProperty('operation', 'testOperation');
-      expect(logEntry).toHaveProperty('error');
-      expect(logEntry.error).toHaveProperty('message', 'Test error');
-      expect(logEntry.error).toHaveProperty('code', 'ETIMEDOUT');
-      expect(logEntry.error).toHaveProperty('type', 'TRANSIENT');
-      expect(logEntry).toHaveProperty('context');
-      expect(logEntry.context).toHaveProperty('userId', 123);
-      expect(logEntry).toHaveProperty('metadata');
-      expect(logEntry.metadata).toHaveProperty('severity');
-      expect(logEntry.metadata).toHaveProperty('environment', 'test');
-    });
-    
-    test('should determine severity from error type', () => {
-      const error = new Error('Fatal error');
-      
-      const logEntry = schema.create({
-        moduleName: 'TestModule',
-        operation: 'testOperation',
-        error: error,
-        serviceName: 'test-service',
-        errorType: 'FATAL'
-      });
-      
-      expect(logEntry.metadata.severity).toBe('fatal');
-    });
-    
-    test('should handle missing optional fields', () => {
-      const error = new Error('Test error');
-      
-      const logEntry = schema.create({
-        moduleName: 'TestModule',
-        operation: 'testOperation',
-        error: error,
-        serviceName: 'test-service'
-      });
-      
-      expect(logEntry).toHaveProperty('timestamp');
-      expect(logEntry.serviceName).toBe('test-service');
-      expect(logEntry.error.type).toBe('UNKNOWN');
-    });
-  });
-});
-