@wgtechlabs/log-engine 2.0.0 → 2.1.0

package/dist/logger/filtering.js

@@ -12,37 +12,52 @@ const types_1 = require("../types");
  */
 class LogFilter {
     /**
-     * Determines if a message should be logged based on current log mode
-     * Messages are shown only if their level is appropriate for the configured mode
-     * LOG level is special - it always outputs regardless of configured mode (except when OFF is set)
-     * OFF mode disables all logging including LOG level messages
-     * @param level - The log level of the message to check
-     * @param currentMode - The current logging mode
-     * @returns true if message should be logged, false otherwise
-     */
+       * Determines if a message should be logged based on current log mode
+       * Messages are shown only if their level is appropriate for the configured mode
+       * LOG level is special - it always outputs regardless of configured mode (except when OFF is set)
+       * OFF mode disables all logging including LOG level messages
+       * @param level - The log level of the message to check
+       * @param currentMode - The current logging mode
+       * @returns true if message should be logged, false otherwise
+       */
     static shouldLog(level, currentMode) {
-        // Get the severity rank for the message level
-        const messageSeverity = this.SEVERITY_RANKS[level];
-        // Get the minimum severity threshold for the current mode
-        const modeThreshold = this.MODE_THRESHOLDS[currentMode];
+        // Get the severity rank for the message level using safe lookup
+        const messageSeverity = LogFilter.getSeverityRank(level);
+        // Get the minimum severity threshold for the current mode using safe lookup
+        const modeThreshold = LogFilter.getModeThreshold(currentMode);
         // Allow the message if its severity meets or exceeds the mode threshold
         return messageSeverity >= modeThreshold;
     }
     /**
-     * Get the severity rank for a log level
-     * @param level - The log level to get rank for
-     * @returns Numeric severity rank
-     */
+       * Get the severity rank for a log level
+       * @param level - The log level to get rank for
+       * @returns Numeric severity rank
+       */
     static getSeverityRank(level) {
-        return this.SEVERITY_RANKS[level];
+        switch (level) {
+            case types_1.LogLevel.DEBUG: return 0;
+            case types_1.LogLevel.INFO: return 1;
+            case types_1.LogLevel.WARN: return 2;
+            case types_1.LogLevel.ERROR: return 3;
+            case types_1.LogLevel.LOG: return 99;
+            default: return 0;
+        }
     }
     /**
-     * Get the threshold for a log mode
-     * @param mode - The log mode to get threshold for
-     * @returns Numeric threshold value
-     */
+       * Get the threshold for a log mode
+       * @param mode - The log mode to get threshold for
+       * @returns Numeric threshold value
+       */
     static getModeThreshold(mode) {
-        return this.MODE_THRESHOLDS[mode];
+        switch (mode) {
+            case types_1.LogMode.DEBUG: return 0;
+            case types_1.LogMode.INFO: return 1;
+            case types_1.LogMode.WARN: return 2;
+            case types_1.LogMode.ERROR: return 3;
+            case types_1.LogMode.SILENT: return 99;
+            case types_1.LogMode.OFF: return 100;
+            default: return 0;
+        }
     }
 }
 exports.LogFilter = LogFilter;

package/dist/redaction/config.d.ts

@@ -14,16 +14,16 @@ export declare const defaultRedactionConfig: RedactionConfig;
  */
 export declare class RedactionController {
     /**
-     * Check if redaction should be disabled based on environment variables
-     * Development mode and explicit flags can disable redaction for debugging
-     * @returns true if redaction should be disabled, false otherwise
-     */
+       * Check if redaction should be disabled based on environment variables
+       * Development mode and explicit flags can disable redaction for debugging
+       * @returns true if redaction should be disabled, false otherwise
+       */
     static isRedactionDisabled(): boolean;
     /**
-     * Get environment-specific configuration overrides
-     * Allows customization through environment variables
-     * @returns Partial redaction config with environment-based overrides
-     */
+       * Get environment-specific configuration overrides
+       * Allows customization through environment variables
+       * @returns Partial redaction config with environment-based overrides
+       */
     static getEnvironmentConfig(): Partial<RedactionConfig>;
 }
 //# sourceMappingURL=config.d.ts.map

package/dist/redaction/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/redaction/config.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAE3C;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAE,eAyCpC,CAAC;AAEF;;;GAGG;AACH,qBAAa,mBAAmB;IAC5B;;;;OAIG;IACH,MAAM,CAAC,mBAAmB,IAAI,OAAO;IAUrC;;;;OAIG;IACH,MAAM,CAAC,oBAAoB,IAAI,OAAO,CAAC,eAAe,CAAC;CA4B1D"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/redaction/config.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAE3C;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAE,eAyCpC,CAAC;AAEF;;;GAGG;AACH,qBAAa,mBAAmB;IAC9B;;;;SAIK;IACL,MAAM,CAAC,mBAAmB,IAAI,OAAO;IAUrC;;;;SAIK;IACL,MAAM,CAAC,oBAAoB,IAAI,OAAO,CAAC,eAAe,CAAC;CA4BxD"}

package/dist/redaction/config.js

@@ -52,10 +52,10 @@ exports.defaultRedactionConfig = {
  */
 class RedactionController {
     /**
-     * Check if redaction should be disabled based on environment variables
-     * Development mode and explicit flags can disable redaction for debugging
-     * @returns true if redaction should be disabled, false otherwise
-     */
+       * Check if redaction should be disabled based on environment variables
+       * Development mode and explicit flags can disable redaction for debugging
+       * @returns true if redaction should be disabled, false otherwise
+       */
     static isRedactionDisabled() {
         return (process.env.NODE_ENV === 'development' ||
             process.env.LOG_REDACTION_DISABLED === 'true' ||
@@ -64,10 +64,10 @@ class RedactionController {
             process.env.LOG_REDACTION_ENABLED === 'false');
     }
     /**
-     * Get environment-specific configuration overrides
-     * Allows customization through environment variables
-     * @returns Partial redaction config with environment-based overrides
-     */
+       * Get environment-specific configuration overrides
+       * Allows customization through environment variables
+       * @returns Partial redaction config with environment-based overrides
+       */
     static getEnvironmentConfig() {
         const envConfig = {
             enabled: !this.isRedactionDisabled()

package/dist/redaction/redactor.d.ts

@@ -2,7 +2,7 @@
  * Core data redaction engine
  * Handles automatic detection and redaction of sensitive information in log data
  */
-import { RedactionConfig } from '../types';
+import { RedactionConfig, LogData } from '../types';
 /**
  * DataRedactor class - Core redaction logic for processing log data
  * Automatically detects and redacts sensitive information while preserving structure
@@ -12,88 +12,88 @@ export declare class DataRedactor {
     private static readonly MAX_RECURSION_DEPTH;
     private static readonly MAX_REDACT_OBJECT_DEPTH;
     /**
-     * Update the redaction configuration with new settings
-     * Merges provided config with existing settings and reloads environment variables
-     * @param newConfig - Partial configuration to merge with current settings
-     */
+       * Update the redaction configuration with new settings
+       * Merges provided config with existing settings and reloads environment variables
+       * @param newConfig - Partial configuration to merge with current settings
+       */
     static updateConfig(newConfig: Partial<RedactionConfig>): void;
     /**
-     * Get the current redaction configuration
-     * @returns Deep copy of current redaction configuration
-     */
+       * Get the current redaction configuration
+       * @returns Deep copy of current redaction configuration
+       */
     static getConfig(): RedactionConfig;
     /**
-     * Refresh configuration from environment variables
-     * Useful for picking up runtime environment changes
-     */
+       * Refresh configuration from environment variables
+       * Useful for picking up runtime environment changes
+       */
     static refreshConfig(): void;
     /**
-     * Add custom regex patterns for advanced field detection
-     * @param patterns - Array of regex patterns to add
-     */
+       * Add custom regex patterns for advanced field detection
+       * @param patterns - Array of regex patterns to add
+       */
     static addCustomPatterns(patterns: RegExp[]): void;
     /**
-     * Clear all custom regex patterns
-     */
+       * Clear all custom regex patterns
+       */
     static clearCustomPatterns(): void;
     /**
-     * Add custom sensitive field names to the existing list
-     * @param fields - Array of field names to add
-     */
+       * Add custom sensitive field names to the existing list
+       * @param fields - Array of field names to add
+       */
     static addSensitiveFields(fields: string[]): void;
     /**
-     * Test if a field name would be redacted with current configuration
-     * @param fieldName - Field name to test
-     * @returns true if field would be redacted, false otherwise
-     */
+       * Test if a field name would be redacted with current configuration
+       * @param fieldName - Field name to test
+       * @returns true if field would be redacted, false otherwise
+       */
     static testFieldRedaction(fieldName: string): boolean;
     /**
-     * Main entry point for data redaction
-     * Processes any type of data and returns a redacted version
-     * @param data - Data to be processed for redaction
-     * @returns Redacted version of the data
-     */
-    static redactData(data: any): any;
+       * Main entry point for data redaction
+       * Processes any type of data and returns a redacted version
+       * @param data - Data to be processed for redaction
+       * @returns Redacted version of the data
+       */
+    static redactData(data: LogData): LogData;
     /**
-     * Process a value of any type (primitive, object, array)
-     * Recursively handles nested structures when deepRedaction is enabled
-     * Includes circular reference protection and recursion depth limiting
-     * @param value - Value to process
-     * @param visited - Set to track visited objects (prevents circular references)
-     * @param depth - Current recursion depth (prevents stack overflow)
-     * @returns Processed value with redaction applied
-     */
+       * Process a value of any type (primitive, object, array)
+       * Recursively handles nested structures when deepRedaction is enabled
+       * Includes circular reference protection and recursion depth limiting
+       * @param value - Value to process
+       * @param visited - Set to track visited objects (prevents circular references)
+       * @param depth - Current recursion depth (prevents stack overflow)
+       * @returns Processed value with redaction applied
+       */
     private static processValue;
     /**
-     * Process an object and redact sensitive fields
-     * Handles field-level redaction and content truncation
-     * @param obj - Object to process
-     * @param visited - Set to track visited objects (prevents circular references)
-     * @param depth - Current recursion depth (prevents stack overflow)
-     * @returns Object with sensitive fields redacted
-     */
+       * Process an object and redact sensitive fields
+       * Handles field-level redaction and content truncation
+       * @param obj - Object to process
+       * @param visited - Set to track visited objects (prevents circular references)
+       * @param depth - Current recursion depth (prevents stack overflow)
+       * @returns Object with sensitive fields redacted
+       */
     private static redactObject;
     /**
-     * Check if a field name indicates sensitive information
-     * Uses case-insensitive matching with exact and partial matches
-     * Includes smart filtering to avoid false positives and custom patterns
-     * @param fieldName - Field name to check
-     * @returns true if field should be redacted, false otherwise
-     */
+       * Check if a field name indicates sensitive information
+       * Uses case-insensitive matching with exact and partial matches
+       * Includes smart filtering to avoid false positives and custom patterns
+       * @param fieldName - Field name to check
+       * @returns true if field should be redacted, false otherwise
+       */
     private static isSensitiveField;
     /**
-     * Check if a field name indicates content that should be truncated
-     * Uses exact case-insensitive matching for content fields
-     * @param fieldName - Field name to check
-     * @returns true if field is a content field, false otherwise
-     */
+       * Check if a field name indicates content that should be truncated
+       * Uses exact case-insensitive matching for content fields
+       * @param fieldName - Field name to check
+       * @returns true if field is a content field, false otherwise
+       */
     private static isContentField;
     /**
-     * Truncate content that exceeds the maximum length
-     * Preserves readability while preventing log bloat
-     * @param content - Content string to potentially truncate
-     * @returns Original content or truncated version with indicator
-     */
+       * Truncate content that exceeds the maximum length
+       * Preserves readability while preventing log bloat
+       * @param content - Content string to potentially truncate
+       * @returns Original content or truncated version with indicator
+       */
     private static truncateContent;
 }
 //# sourceMappingURL=redactor.d.ts.map

package/dist/redaction/redactor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"redactor.d.ts","sourceRoot":"","sources":["../../src/redaction/redactor.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAG3C;;;GAGG;AACH,qBAAa,YAAY;IACrB,OAAO,CAAC,MAAM,CAAC,MAAM,CAGnB;IAGF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,mBAAmB,CAAO;IAElD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,uBAAuB,CAAM;IAErD;;;;OAIG;IACH,MAAM,CAAC,YAAY,CAAC,SAAS,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,IAAI;IAU9D;;;OAGG;IACH,MAAM,CAAC,SAAS,IAAI,eAAe;IASnC;;;OAGG;IACH,MAAM,CAAC,aAAa,IAAI,IAAI;IAQ5B;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI;IAQlD;;OAEG;IACH,MAAM,CAAC,mBAAmB,IAAI,IAAI;IAOlC;;;OAGG;IACH,MAAM,CAAC,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI;IAOjD;;;;OAIG;IACH,MAAM,CAAC,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAMrD;;;;;OAKG;IACH,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,GAAG,GAAG,GAAG;IASjC;;;;;;;;OAQG;IACH,OAAO,CAAC,MAAM,CAAC,YAAY;IAyC3B;;;;;;;OAOG;IACH,OAAO,CAAC,MAAM,CAAC,YAAY;IA8B3B;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAgD/B;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,cAAc;IAK7B;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;CAMjC"}
+{"version":3,"file":"redactor.d.ts","sourceRoot":"","sources":["../../src/redaction/redactor.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAGpD;;;GAGG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAC,MAAM,CAGnB;IAGF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,mBAAmB,CAAO;IAElD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,uBAAuB,CAAM;IAErD;;;;SAIK;IACL,MAAM,CAAC,YAAY,CAAC,SAAS,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,IAAI;IAU9D;;;SAGK;IACL,MAAM,CAAC,SAAS,IAAI,eAAe;IASnC;;;SAGK;IACL,MAAM,CAAC,aAAa,IAAI,IAAI;IAQ5B;;;SAGK;IACL,MAAM,CAAC,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI;IAQlD;;SAEK;IACL,MAAM,CAAC,mBAAmB,IAAI,IAAI;IAOlC;;;SAGK;IACL,MAAM,CAAC,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI;IAOjD;;;;SAIK;IACL,MAAM,CAAC,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAWrD;;;;;SAKK;IACL,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO;IASzC;;;;;;;;SAQK;IACL,OAAO,CAAC,MAAM,CAAC,YAAY;IAyC3B;;;;;;;SAOK;IACL,OAAO,CAAC,MAAM,CAAC,YAAY;IA2B3B;;;;;;SAMK;IACL,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAgD/B;;;;;SAKK;IACL,OAAO,CAAC,MAAM,CAAC,cAAc;IAK7B;;;;;SAKK;IACL,OAAO,CAAC,MAAM,CAAC,eAAe;CAM/B"}

package/dist/redaction/redactor.js

@@ -12,107 +12,112 @@ const config_1 = require("./config");
  */
 class DataRedactor {
     /**
-     * Update the redaction configuration with new settings
-     * Merges provided config with existing settings and reloads environment variables
-     * @param newConfig - Partial configuration to merge with current settings
-     */
+       * Update the redaction configuration with new settings
+       * Merges provided config with existing settings and reloads environment variables
+       * @param newConfig - Partial configuration to merge with current settings
+       */
     static updateConfig(newConfig) {
         // Reload environment configuration to pick up any changes
         const envConfig = config_1.RedactionController.getEnvironmentConfig();
-        this.config = {
+        DataRedactor.config = {
             ...config_1.defaultRedactionConfig,
             ...envConfig,
             ...newConfig
         };
     }
     /**
-     * Get the current redaction configuration
-     * @returns Deep copy of current redaction configuration
-     */
+       * Get the current redaction configuration
+       * @returns Deep copy of current redaction configuration
+       */
     static getConfig() {
         return {
-            ...this.config,
-            sensitiveFields: [...this.config.sensitiveFields],
-            contentFields: [...this.config.contentFields],
-            customPatterns: this.config.customPatterns ? [...this.config.customPatterns] : undefined
+            ...DataRedactor.config,
+            sensitiveFields: [...DataRedactor.config.sensitiveFields],
+            contentFields: [...DataRedactor.config.contentFields],
+            customPatterns: DataRedactor.config.customPatterns ? [...DataRedactor.config.customPatterns] : undefined
         };
     }
     /**
-     * Refresh configuration from environment variables
-     * Useful for picking up runtime environment changes
-     */
+       * Refresh configuration from environment variables
+       * Useful for picking up runtime environment changes
+       */
     static refreshConfig() {
         const envConfig = config_1.RedactionController.getEnvironmentConfig();
-        this.config = {
+        DataRedactor.config = {
             ...config_1.defaultRedactionConfig,
             ...envConfig
         };
     }
     /**
-     * Add custom regex patterns for advanced field detection
-     * @param patterns - Array of regex patterns to add
-     */
+       * Add custom regex patterns for advanced field detection
+       * @param patterns - Array of regex patterns to add
+       */
     static addCustomPatterns(patterns) {
-        const currentPatterns = this.config.customPatterns || [];
-        this.config = {
-            ...this.config,
+        const currentPatterns = DataRedactor.config.customPatterns || [];
+        DataRedactor.config = {
+            ...DataRedactor.config,
             customPatterns: [...currentPatterns, ...patterns]
         };
     }
     /**
-     * Clear all custom regex patterns
-     */
+       * Clear all custom regex patterns
+       */
     static clearCustomPatterns() {
-        this.config = {
-            ...this.config,
+        DataRedactor.config = {
+            ...DataRedactor.config,
             customPatterns: []
         };
     }
     /**
-     * Add custom sensitive field names to the existing list
-     * @param fields - Array of field names to add
-     */
+       * Add custom sensitive field names to the existing list
+       * @param fields - Array of field names to add
+       */
     static addSensitiveFields(fields) {
-        this.config = {
-            ...this.config,
-            sensitiveFields: [...this.config.sensitiveFields, ...fields]
+        DataRedactor.config = {
+            ...DataRedactor.config,
+            sensitiveFields: [...DataRedactor.config.sensitiveFields, ...fields]
         };
     }
     /**
-     * Test if a field name would be redacted with current configuration
-     * @param fieldName - Field name to test
-     * @returns true if field would be redacted, false otherwise
-     */
+       * Test if a field name would be redacted with current configuration
+       * @param fieldName - Field name to test
+       * @returns true if field would be redacted, false otherwise
+       */
     static testFieldRedaction(fieldName) {
         const testObj = { [fieldName]: 'test-value' };
-        const result = this.redactData(testObj);
-        return result[fieldName] !== 'test-value';
+        const result = DataRedactor.redactData(testObj); // Use safe property access to prevent object injection
+        if (Object.prototype.hasOwnProperty.call(result, fieldName)) {
+            // Safe access to avoid object injection
+            const value = result[fieldName];
+            return value !== 'test-value';
+        }
+        return false;
     }
     /**
-     * Main entry point for data redaction
-     * Processes any type of data and returns a redacted version
-     * @param data - Data to be processed for redaction
-     * @returns Redacted version of the data
-     */
+       * Main entry point for data redaction
+       * Processes any type of data and returns a redacted version
+       * @param data - Data to be processed for redaction
+       * @returns Redacted version of the data
+       */
     static redactData(data) {
         // Skip processing if redaction is disabled or data is null/undefined
-        if (!this.config.enabled || data === null || data === undefined) {
+        if (!DataRedactor.config.enabled || data === null || data === undefined) {
             return data;
         }
-        return this.processValue(data, new WeakSet(), 0);
+        return DataRedactor.processValue(data, new WeakSet(), 0);
     }
     /**
-     * Process a value of any type (primitive, object, array)
-     * Recursively handles nested structures when deepRedaction is enabled
-     * Includes circular reference protection and recursion depth limiting
-     * @param value - Value to process
-     * @param visited - Set to track visited objects (prevents circular references)
-     * @param depth - Current recursion depth (prevents stack overflow)
-     * @returns Processed value with redaction applied
-     */
+       * Process a value of any type (primitive, object, array)
+       * Recursively handles nested structures when deepRedaction is enabled
+       * Includes circular reference protection and recursion depth limiting
+       * @param value - Value to process
+       * @param visited - Set to track visited objects (prevents circular references)
+       * @param depth - Current recursion depth (prevents stack overflow)
+       * @returns Processed value with redaction applied
+       */
     static processValue(value, visited = new WeakSet(), depth = 0) {
         // Check recursion depth limit to prevent stack overflow
-        if (depth >= this.MAX_RECURSION_DEPTH) {
+        if (depth >= DataRedactor.MAX_RECURSION_DEPTH) {
             return '[Max Depth Exceeded]';
         }
         // Handle null and undefined
@@ -126,7 +131,7 @@ class DataRedactor {
                 return '[Circular Array]';
             }
             visited.add(value);
-            const result = value.map(item => this.processValue(item, visited, depth + 1));
+            const result = value.map(item => DataRedactor.processValue(item, visited, depth + 1));
             // Keep value in visited set to detect circular references across branches
             return result;
         }
@@ -137,7 +142,7 @@ class DataRedactor {
                 return '[Circular Object]';
             }
             visited.add(value);
-            const result = this.redactObject(value, visited, depth + 1);
+            const result = DataRedactor.redactObject(value, visited, depth + 1);
             // Keep value in visited set to detect circular references across branches
             return result;
         }
@@ -145,57 +150,57 @@ class DataRedactor {
         return value;
     }
     /**
-     * Process an object and redact sensitive fields
-     * Handles field-level redaction and content truncation
-     * @param obj - Object to process
-     * @param visited - Set to track visited objects (prevents circular references)
-     * @param depth - Current recursion depth (prevents stack overflow)
-     * @returns Object with sensitive fields redacted
-     */
+       * Process an object and redact sensitive fields
+       * Handles field-level redaction and content truncation
+       * @param obj - Object to process
+       * @param visited - Set to track visited objects (prevents circular references)
+       * @param depth - Current recursion depth (prevents stack overflow)
+       * @returns Object with sensitive fields redacted
+       */
     static redactObject(obj, visited = new WeakSet(), depth = 0) {
         // Check recursion depth limit to prevent stack overflow
-        if (depth >= this.MAX_REDACT_OBJECT_DEPTH) {
+        if (depth >= DataRedactor.MAX_REDACT_OBJECT_DEPTH) {
             return { '[Max Depth Exceeded]': '[Max Depth Exceeded]' };
         }
         const redacted = {};
         for (const [key, value] of Object.entries(obj)) {
             // Check if this field should be completely redacted
-            if (this.isSensitiveField(key)) {
-                redacted[key] = this.config.redactionText;
+            if (DataRedactor.isSensitiveField(key)) {
+                Object.defineProperty(redacted, key, { value: DataRedactor.config.redactionText, enumerable: true, writable: true, configurable: true });
             }
-            // Check if this field should be truncated (for large content)
-            else if (this.isContentField(key) && typeof value === 'string') {
-                redacted[key] = this.truncateContent(value);
+            else if (DataRedactor.isContentField(key) && typeof value === 'string') {
+                // Check if this field should be truncated (for large content)
+                Object.defineProperty(redacted, key, { value: DataRedactor.truncateContent(value), enumerable: true, writable: true, configurable: true });
             }
-            // Recursively process nested objects/arrays if deep redaction is enabled
-            else if (this.config.deepRedaction && (typeof value === 'object' && value !== null)) {
-                redacted[key] = this.processValue(value, visited, depth + 1);
+            else if (DataRedactor.config.deepRedaction && (typeof value === 'object' && value !== null)) {
+                // Recursively process nested objects/arrays if deep redaction is enabled
+                Object.defineProperty(redacted, key, { value: DataRedactor.processValue(value, visited, depth + 1), enumerable: true, writable: true, configurable: true });
             }
-            // Keep the value unchanged
             else {
-                redacted[key] = value;
+                // Keep the value unchanged
+                Object.defineProperty(redacted, key, { value: value, enumerable: true, writable: true, configurable: true });
             }
         }
         return redacted;
     }
     /**
-     * Check if a field name indicates sensitive information
-     * Uses case-insensitive matching with exact and partial matches
-     * Includes smart filtering to avoid false positives and custom patterns
-     * @param fieldName - Field name to check
-     * @returns true if field should be redacted, false otherwise
-     */
+       * Check if a field name indicates sensitive information
+       * Uses case-insensitive matching with exact and partial matches
+       * Includes smart filtering to avoid false positives and custom patterns
+       * @param fieldName - Field name to check
+       * @returns true if field should be redacted, false otherwise
+       */
     static isSensitiveField(fieldName) {
         const lowerField = fieldName.toLowerCase();
         // Check custom regex patterns first (highest priority)
-        if (this.config.customPatterns && this.config.customPatterns.length > 0) {
-            for (const pattern of this.config.customPatterns) {
+        if (DataRedactor.config.customPatterns && DataRedactor.config.customPatterns.length > 0) {
+            for (const pattern of DataRedactor.config.customPatterns) {
                 if (pattern.test(fieldName)) {
                     return true;
                 }
             }
         }
-        return this.config.sensitiveFields.some(sensitive => {
+        return DataRedactor.config.sensitiveFields.some(sensitive => {
             const lowerSensitive = sensitive.toLowerCase();
             // Exact match (highest confidence)
             if (lowerField === lowerSensitive) {
@@ -224,26 +229,26 @@ class DataRedactor {
         });
     }
     /**
-     * Check if a field name indicates content that should be truncated
-     * Uses exact case-insensitive matching for content fields
-     * @param fieldName - Field name to check
-     * @returns true if field is a content field, false otherwise
-     */
+       * Check if a field name indicates content that should be truncated
+       * Uses exact case-insensitive matching for content fields
+       * @param fieldName - Field name to check
+       * @returns true if field is a content field, false otherwise
+       */
     static isContentField(fieldName) {
         const lowerField = fieldName.toLowerCase();
-        return this.config.contentFields.some(content => content.toLowerCase() === lowerField);
+        return DataRedactor.config.contentFields.some(content => content.toLowerCase() === lowerField);
     }
     /**
-     * Truncate content that exceeds the maximum length
-     * Preserves readability while preventing log bloat
-     * @param content - Content string to potentially truncate
-     * @returns Original content or truncated version with indicator
-     */
+       * Truncate content that exceeds the maximum length
+       * Preserves readability while preventing log bloat
+       * @param content - Content string to potentially truncate
+       * @returns Original content or truncated version with indicator
+       */
     static truncateContent(content) {
-        if (content.length <= this.config.maxContentLength) {
+        if (content.length <= DataRedactor.config.maxContentLength) {
             return content;
         }
-        return content.substring(0, this.config.maxContentLength) + this.config.truncationText;
+        return content.substring(0, DataRedactor.config.maxContentLength) + DataRedactor.config.truncationText;
     }
 }
 exports.DataRedactor = DataRedactor;