@sschepis/magazine 0.1.0

package/src/components/DataCompressor.js

@@ -0,0 +1,378 @@
+/**
+ * DataCompressor - Handles data compression and decompression for storage optimization
+ */
+import { gzip, ungzip } from 'pako';
+
+const isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+
+function toBase64(uint8Array) {
+    if (isNode) {
+        return Buffer.from(uint8Array).toString('base64');
+    }
+    return btoa(String.fromCharCode.apply(null, uint8Array));
+}
+
+function fromBase64(base64String) {
+    if (isNode) {
+        const buf = Buffer.from(base64String, 'base64');
+        return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+    }
+    const binaryString = atob(base64String);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes;
+}
+
+export default class DataCompressor {
+    constructor(logger) {
+        this.logger = logger.child({ context: 'DataCompressor' });
+        this.logger.info('DataCompressor initialized');
+        
+        // Compression strategies
+        this.strategies = {
+            none: {
+                compress: (data) => data,
+                decompress: (data) => data,
+                ratio: 1
+            },
+            json: {
+                compress: (data) => this._compressJSON(data),
+                decompress: (data) => this._decompressJSON(data),
+                ratio: 0.7 // Approximate
+            },
+            gzip: {
+                compress: (data) => this._compressGzip(data),
+                decompress: (data) => this._decompressGzip(data),
+                ratio: 0.3 // Approximate
+            },
+            optimized: {
+                compress: (data) => this._compressOptimized(data),
+                decompress: (data) => this._decompressOptimized(data),
+                ratio: 0.4 // Approximate
+            }
+        };
+        
+        this.defaultStrategy = 'optimized';
+    }
+
+    /**
+     * Compress data using specified strategy
+     * @param {any} data - Data to compress
+     * @param {string} strategy - Compression strategy
+     * @returns {Object} Compressed data with metadata
+     */
+    compress(data, strategy = this.defaultStrategy) {
+        try {
+            const startTime = Date.now();
+            const originalSize = this._calculateSize(data);
+            
+            if (!this.strategies[strategy]) {
+                this.logger.warn('Unknown compression strategy, using default', { strategy });
+                strategy = this.defaultStrategy;
+            }
+            
+            const compressed = this.strategies[strategy].compress(data);
+            const compressedSize = this._calculateSize(compressed);
+            const compressionRatio = compressedSize / originalSize;
+            const duration = Date.now() - startTime;
+            
+            const result = {
+                data: compressed,
+                metadata: {
+                    strategy,
+                    originalSize,
+                    compressedSize,
+                    compressionRatio: compressionRatio.toFixed(3),
+                    spaceSaved: `${((1 - compressionRatio) * 100).toFixed(1)}%`,
+                    compressionTime: duration,
+                    timestamp: new Date().toISOString()
+                }
+            };
+            
+            this.logger.debug('Data compressed', result.metadata);
+            return result;
+            
+        } catch (error) {
+            this.logger.error('Compression failed', { strategy, error: error.message });
+            throw error;
+        }
+    }
+
+    /**
+     * Decompress data
+     * @param {Object} compressedData - Compressed data with metadata
+     * @returns {any} Original data
+     */
+    decompress(compressedData) {
+        try {
+            if (!compressedData.metadata || !compressedData.metadata.strategy) {
+                this.logger.warn('No compression metadata found, assuming no compression');
+                return compressedData;
+            }
+            
+            const { strategy } = compressedData.metadata;
+            const startTime = Date.now();
+            
+            if (!this.strategies[strategy]) {
+                throw new Error(`Unknown compression strategy: ${strategy}`);
+            }
+            
+            const decompressed = this.strategies[strategy].decompress(compressedData.data);
+            const duration = Date.now() - startTime;
+            
+            this.logger.debug('Data decompressed', {
+                strategy,
+                decompressionTime: duration,
+                originalSize: compressedData.metadata.originalSize
+            });
+            
+            return decompressed;
+            
+        } catch (error) {
+            this.logger.error('Decompression failed', { error: error.message });
+            throw error;
+        }
+    }
+
+    /**
+     * Compress events for storage
+     * @param {Array} events - Events to compress
+     * @param {Object} options - Compression options
+     * @returns {Object} Compressed events
+     */
+    compressEvents(events, options = {}) {
+        const { strategy = this.defaultStrategy, chunkSize = 100 } = options;
+        
+        return this.logger.time('compressEvents', () => {
+            // Group events into chunks for better compression
+            const chunks = [];
+            for (let i = 0; i < events.length; i += chunkSize) {
+                chunks.push(events.slice(i, i + chunkSize));
+            }
+            
+            // Compress each chunk
+            const compressedChunks = chunks.map((chunk, index) => {
+                const compressed = this.compress(chunk, strategy);
+                return {
+                    ...compressed,
+                    metadata: {
+                        ...compressed.metadata,
+                        chunkIndex: index,
+                        eventCount: chunk.length
+                    }
+                };
+            });
+            
+            // Calculate total compression stats
+            const totalOriginal = compressedChunks.reduce((sum, c) => sum + c.metadata.originalSize, 0);
+            const totalCompressed = compressedChunks.reduce((sum, c) => sum + c.metadata.compressedSize, 0);
+            
+            const result = {
+                chunks: compressedChunks,
+                metadata: {
+                    totalEvents: events.length,
+                    chunkCount: chunks.length,
+                    strategy,
+                    totalOriginalSize: totalOriginal,
+                    totalCompressedSize: totalCompressed,
+                    overallCompressionRatio: (totalCompressed / totalOriginal).toFixed(3),
+                    spaceSaved: `${((1 - totalCompressed / totalOriginal) * 100).toFixed(1)}%`
+                }
+            };
+            
+            this.logger.info('Events compressed', result.metadata);
+            return result;
+        });
+    }
+
+    /**
+     * Decompress events
+     * @param {Object} compressedEvents - Compressed events object
+     * @returns {Array} Original events
+     */
+    decompressEvents(compressedEvents) {
+        return this.logger.time('decompressEvents', () => {
+            if (!compressedEvents.chunks || !Array.isArray(compressedEvents.chunks)) {
+                throw new Error('Invalid compressed events format');
+            }
+            
+            const events = [];
+            
+            // Decompress each chunk
+            compressedEvents.chunks.forEach(chunk => {
+                const decompressedChunk = this.decompress(chunk);
+                events.push(...decompressedChunk);
+            });
+            
+            this.logger.info('Events decompressed', {
+                totalEvents: events.length,
+                chunks: compressedEvents.chunks.length
+            });
+            
+            return events;
+        });
+    }
+
+    /**
+     * JSON compression - removes whitespace and uses short keys
+     * @private
+     */
+    _compressJSON(data) {
+        // Create key mapping for common event fields
+        const keyMap = {
+            eventName: 'e',
+            blockNumber: 'b',
+            transactionHash: 't',
+            address: 'a',
+            args: 'r',
+            topics: 'p',
+            data: 'd',
+            logIndex: 'l',
+            transactionIndex: 'i',
+            blockHash: 'h',
+            removed: 'm'
+        };
+        
+        const compressed = this._replaceKeys(data, keyMap);
+        return {
+            d: compressed,
+            k: keyMap
+        };
+    }
+
+    /**
+     * JSON decompression
+     * @private
+     */
+    _decompressJSON(compressed) {
+        if (!compressed.d || !compressed.k) {
+            return compressed;
+        }
+        
+        // Reverse the key mapping
+        const reverseMap = {};
+        Object.entries(compressed.k).forEach(([k, v]) => {
+            reverseMap[v] = k;
+        });
+        
+        return this._replaceKeys(compressed.d, reverseMap);
+    }
+
+    /**
+     * Gzip compression
+     * @private
+     */
+    _compressGzip(data) {
+        const jsonString = JSON.stringify(data);
+        const compressed = gzip(jsonString);
+        return toBase64(compressed);
+    }
+
+    /**
+     * Gzip decompression
+     * @private
+     */
+    _decompressGzip(compressed) {
+        const bytes = fromBase64(compressed);
+        const decompressed = ungzip(bytes);
+        const jsonString = new TextDecoder().decode(decompressed);
+        return JSON.parse(jsonString);
+    }
+
+    /**
+     * Optimized compression - combines JSON and gzip
+     * @private
+     */
+    _compressOptimized(data) {
+        // First apply JSON compression
+        const jsonCompressed = this._compressJSON(data);
+        // Then apply gzip
+        return this._compressGzip(jsonCompressed);
+    }
+
+    /**
+     * Optimized decompression
+     * @private
+     */
+    _decompressOptimized(compressed) {
+        // First decompress gzip
+        const gzipDecompressed = this._decompressGzip(compressed);
+        // Then decompress JSON
+        return this._decompressJSON(gzipDecompressed);
+    }
+
+    /**
+     * Replace keys in object recursively
+     * @private
+     */
+    _replaceKeys(obj, keyMap) {
+        if (Array.isArray(obj)) {
+            return obj.map(item => this._replaceKeys(item, keyMap));
+        } else if (obj !== null && typeof obj === 'object') {
+            const result = {};
+            Object.entries(obj).forEach(([key, value]) => {
+                const newKey = keyMap[key] || key;
+                result[newKey] = this._replaceKeys(value, keyMap);
+            });
+            return result;
+        }
+        return obj;
+    }
+
+    /**
+     * Calculate size of data in bytes
+     * @private
+     */
+    _calculateSize(data) {
+        const jsonString = JSON.stringify(data);
+        if (isNode) {
+            return Buffer.byteLength(jsonString, 'utf8');
+        }
+        return new Blob([jsonString]).size;
+    }
+
+    /**
+     * Analyze compression efficiency for different strategies
+     * @param {any} data - Data to analyze
+     * @returns {Object} Analysis results
+     */
+    analyzeCompressionStrategies(data) {
+        const results = {};
+        
+        Object.keys(this.strategies).forEach(strategy => {
+            try {
+                const compressed = this.compress(data, strategy);
+                results[strategy] = {
+                    originalSize: compressed.metadata.originalSize,
+                    compressedSize: compressed.metadata.compressedSize,
+                    compressionRatio: compressed.metadata.compressionRatio,
+                    spaceSaved: compressed.metadata.spaceSaved,
+                    compressionTime: compressed.metadata.compressionTime
+                };
+            } catch (error) {
+                results[strategy] = {
+                    error: error.message
+                };
+            }
+        });
+        
+        // Find best strategy
+        let bestStrategy = 'none';
+        let bestRatio = 1;
+        
+        Object.entries(results).forEach(([strategy, result]) => {
+            if (!result.error && parseFloat(result.compressionRatio) < bestRatio) {
+                bestRatio = parseFloat(result.compressionRatio);
+                bestStrategy = strategy;
+            }
+        });
+        
+        return {
+            strategies: results,
+            recommendation: bestStrategy,
+            bestCompressionRatio: bestRatio
+        };
+    }
+}