🚀 release: v1.3.0 - Merge pull request #10 from wgtechlabs/dev

Author: warengonzaga

.gitignore

@@ -134,3 +134,5 @@ dist
 .yarn/build-state.yml
 .yarn/install-state.gz
 .pnp.*
+
+examples/

README.md

@@ -1,3 +1,7 @@
+/**
+ * Jest configuration for Log Engine testing
+ * Provides comprehensive test coverage with TypeScript support
+ */
 module.exports = {
   preset: 'ts-jest',
   testEnvironment: 'node',

jest.config.js

@@ -1,14 +1,21 @@
 {
   "name": "@wgtechlabs/log-engine",
-  "version": "1.2.1",
-  "description": "A lightweight and efficient logging utility designed specifically for bot applications running on Node.js.",
+  "version": "1.3.0",
+  "description": "A lightweight, security-first logging utility with automatic data redaction for Node.js applications - the first logging library with built-in PII protection.",
   "keywords": [
     "logging",
+    "security",
+    "redaction",
+    "pii-protection",
+    "data-redaction",
+    "typescript",
+    "nodejs",
     "bot",
     "discord",
     "telegram",
-    "nodejs",
-    "typescript"
+    "privacy",
+    "gdpr",
+    "compliance"
   ],
   "license": "AGPL-3.0",
   "author": "WG Tech Labs <opensource@wgtechlabs.com> (https://wgtechlabs.com)",

package.json

@@ -4,6 +4,8 @@
  */
 
 import { setupConsoleMocks, restoreConsoleMocks, ConsoleMocks } from './test-utils';
+import { EnvironmentDetector } from '../logger/environment';
+import { LogMode } from '../types';
 
 describe('Environment-based configuration', () => {
   const originalNodeEnv = process.env.NODE_ENV;
@@ -20,6 +22,58 @@ describe('Environment-based configuration', () => {
     restoreConsoleMocks(mocks);
   });
 
+  describe('EnvironmentDetector direct tests', () => {
+    it('should detect test environment correctly', () => {
+      process.env.NODE_ENV = 'test';
+      expect(EnvironmentDetector.isTestEnvironment()).toBe(true);
+      expect(EnvironmentDetector.isDevelopmentEnvironment()).toBe(false);
+      expect(EnvironmentDetector.isProductionEnvironment()).toBe(false);
+    });
+
+    it('should detect development environment correctly', () => {
+      process.env.NODE_ENV = 'development';
+      expect(EnvironmentDetector.isDevelopmentEnvironment()).toBe(true);
+      expect(EnvironmentDetector.isTestEnvironment()).toBe(false);
+      expect(EnvironmentDetector.isProductionEnvironment()).toBe(false);
+    });
+
+    it('should detect production environment correctly', () => {
+      process.env.NODE_ENV = 'production';
+      expect(EnvironmentDetector.isProductionEnvironment()).toBe(true);
+      expect(EnvironmentDetector.isTestEnvironment()).toBe(false);
+      expect(EnvironmentDetector.isDevelopmentEnvironment()).toBe(false);
+    });
+
+    it('should return correct log mode for each environment', () => {
+      process.env.NODE_ENV = 'development';
+      expect(EnvironmentDetector.getEnvironmentMode()).toBe(LogMode.DEBUG);
+
+      process.env.NODE_ENV = 'production';
+      expect(EnvironmentDetector.getEnvironmentMode()).toBe(LogMode.INFO);
+
+      process.env.NODE_ENV = 'staging';
+      expect(EnvironmentDetector.getEnvironmentMode()).toBe(LogMode.WARN);
+
+      process.env.NODE_ENV = 'test';
+      expect(EnvironmentDetector.getEnvironmentMode()).toBe(LogMode.ERROR);
+
+      process.env.NODE_ENV = 'unknown';
+      expect(EnvironmentDetector.getEnvironmentMode()).toBe(LogMode.INFO);
+    });
+
+    it('should handle whitespace in NODE_ENV', () => {
+      process.env.NODE_ENV = '  production  ';
+      expect(EnvironmentDetector.isProductionEnvironment()).toBe(true);
+      expect(EnvironmentDetector.getEnvironmentMode()).toBe(LogMode.INFO);
+    });
+
+    it('should handle case insensitive NODE_ENV', () => {
+      process.env.NODE_ENV = 'PRODUCTION';
+      expect(EnvironmentDetector.isProductionEnvironment()).toBe(true);
+      expect(EnvironmentDetector.getEnvironmentMode()).toBe(LogMode.INFO);
+    });
+  });
+
   it('should set INFO mode for production environment', () => {
     // Test production environment auto-configuration (show important info and above)
     process.env.NODE_ENV = 'production';

src/__tests__/environment.test.ts

@@ -5,6 +5,7 @@
 
 import { LogFormatter } from '../formatter';
 import { LogLevel } from '../types';
+import { styleData } from '../formatter/data-formatter';
 
 describe('LogFormatter', () => {
   it('should format messages with timestamp and level', () => {
@@ -94,8 +95,9 @@ describe('LogFormatter', () => {
       expect(formatted).toContain(message);
 
       // Should contain timestamp components
-      expect(formatted).toMatch(/\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z\]/); // ISO timestamp
-      expect(formatted).toMatch(/\[\d{1,2}:\d{2}[AP]M\]/); // Local time
+      const cleanFormatted = formatted.replace(/\x1b\[[0-9;]*m/g, '');
+      expect(cleanFormatted).toMatch(/\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z\]/); // ISO timestamp
+      expect(cleanFormatted).toMatch(/\[\d{1,2}:\d{2}[AP]M\]/); // Local time
     });
 
     it('should format system messages with colors', () => {
@@ -122,4 +124,124 @@ describe('LogFormatter', () => {
       expect(cleanFormatted).toMatch(formatPattern);
     });
   });
+
+  describe('formatData edge cases', () => {
+    it('should handle null values', () => {
+      // Test null handling (covers line 98)
+      const formatted = LogFormatter.format(LogLevel.INFO, 'Message', null);
+      expect(formatted).toContain('null');
+    });
+
+    it('should handle undefined values', () => {
+      // Test undefined handling (covers line 102)
+      const formatted = LogFormatter.format(LogLevel.INFO, 'Message', undefined);
+      expect(formatted).toContain('Message');
+      // The formatted message should not contain 'undefined'
+      // Remove ANSI color codes before pattern matching
+      const cleanFormatted = formatted.replace(/\x1b\[[0-9;]*m/g, '');
+      expect(cleanFormatted).toMatch(/Message$/);
+    });
+
+    it('should handle number values', () => {
+      // Test number handling (covers line 106)
+      const formatted = LogFormatter.format(LogLevel.INFO, 'Message', 42);
+      expect(formatted).toContain('42');
+    });
+
+    it('should handle boolean values', () => {
+      // Test boolean handling (covers line 110)
+      const formatted = LogFormatter.format(LogLevel.INFO, 'Message', true);
+      expect(formatted).toContain('true');
+      
+      const formatted2 = LogFormatter.format(LogLevel.INFO, 'Message', false);
+      expect(formatted2).toContain('false');
+    });
+
+    it('should handle objects that cannot be stringified', () => {
+      // Test JSON.stringify error handling (covers line 117)
+      const circularObj: any = {};
+      circularObj.self = circularObj; // Create circular reference
+      
+      const formatted = LogFormatter.format(LogLevel.INFO, 'Message', circularObj);
+      expect(formatted).toContain('[Object]');
+    });
+
+    it('should handle string data types', () => {
+      // Test to cover line 106 - string handling
+      const formatted = LogFormatter.format(LogLevel.INFO, 'Message', 'test string');
+      expect(formatted).toContain('test string');
+    });
+
+    it('should handle undefined values in formatData', () => {
+      // Test to cover line 102 - undefined returns empty string
+      // Import the formatData function from the new modular structure
+      const { formatData } = require('../formatter/data-formatter');
+      const result = formatData(undefined);
+      expect(result).toBe('');
+    });
+
+    it('should handle Symbol values in formatData', () => {
+      // Test to verify Symbol handling - should return string representation
+      const { formatData } = require('../formatter/data-formatter');
+      const testSymbol = Symbol('test');
+      const result = formatData(testSymbol);
+      expect(typeof result).toBe('string');
+      expect(result).toBe('Symbol(test)');
+    });
+
+    it('should handle Symbol values without description in formatData', () => {
+      // Test to verify Symbol handling for symbols without description
+      const { formatData } = require('../formatter/data-formatter');
+      const testSymbol = Symbol();
+      const result = formatData(testSymbol);
+      expect(typeof result).toBe('string');
+      expect(result).toBe('Symbol()');
+    });
+  });
+
+  describe('styleData function', () => {
+    const mockColors = { data: '\x1b[36m', reset: '\x1b[0m' };
+
+    it('should return empty string for empty dataString', () => {
+      // Test to cover line 45 - empty string case
+      expect(styleData('', mockColors)).toBe('');
+    });
+
+    it('should return empty string for null/undefined dataString', () => {
+      // Test to cover line 45 - falsy values
+      expect(styleData(null as any, mockColors)).toBe('');
+      expect(styleData(undefined as any, mockColors)).toBe('');
+    });
+
+    it('should style non-empty data string correctly', () => {
+      // Test normal case
+      const result = styleData('test data', mockColors);
+      expect(result).toBe(` ${mockColors.data}test data${mockColors.reset}`);
+    });
+  });
+
+  describe('Module exports', () => {
+    it('should export all formatter functions and classes', () => {
+      const formatter = require('../formatter');
+      
+      // Test that all expected exports are available
+      expect(formatter.MessageFormatter).toBeDefined();
+      expect(formatter.LogFormatter).toBeDefined(); // Backward compatibility
+      expect(formatter.colors).toBeDefined();
+      expect(formatter.colorScheme).toBeDefined();
+      expect(formatter.getTimestampComponents).toBeDefined();
+      expect(formatter.formatTimestamp).toBeDefined();
+      expect(formatter.formatData).toBeDefined();
+      expect(formatter.styleData).toBeDefined();
+      
+      // Test that LogFormatter is alias for MessageFormatter
+      expect(formatter.LogFormatter).toBe(formatter.MessageFormatter);
+      
+      // Test that functions are callable
+      expect(typeof formatter.getTimestampComponents).toBe('function');
+      expect(typeof formatter.formatTimestamp).toBe('function');
+      expect(typeof formatter.formatData).toBe('function');
+      expect(typeof formatter.styleData).toBe('function');
+    });
+  });
 });

src/__tests__/formatter.test.ts

@@ -223,6 +223,37 @@ it('should log LOG level messages regardless of configuration', () => {
       expect(mocks.mockConsoleError).not.toHaveBeenCalled();
     });
   });
+
+  describe('Main module exports', () => {
+    it('should export LogEngine and all types', () => {
+      const main = require('../index');
+      
+      // Test that main exports are available
+      expect(main.LogEngine).toBeDefined();
+      expect(main.LogLevel).toBeDefined();
+      expect(main.LogMode).toBeDefined();
+      
+      // Test that LogEngine has expected methods
+      expect(typeof main.LogEngine.debug).toBe('function');
+      expect(typeof main.LogEngine.info).toBe('function');
+      expect(typeof main.LogEngine.warn).toBe('function');
+      expect(typeof main.LogEngine.error).toBe('function');
+      expect(typeof main.LogEngine.log).toBe('function');
+    });
+
+    it('should test withoutRedaction method', () => {
+      const main = require('../index');
+      const withoutRedaction = main.LogEngine.withoutRedaction();
+      
+      // Test that withoutRedaction returns an object with logging methods
+      expect(withoutRedaction).toBeDefined();
+      expect(typeof withoutRedaction.debug).toBe('function');
+      expect(typeof withoutRedaction.info).toBe('function');
+      expect(typeof withoutRedaction.warn).toBe('function');
+      expect(typeof withoutRedaction.error).toBe('function');
+      expect(typeof withoutRedaction.log).toBe('function');
+    });
+  });
 });