@sschepis/magazine 0.1.0

package/src/components/EventStore.js

@@ -0,0 +1,443 @@
+import Gun from 'gun';
+import 'gun/lib/load.js';
+import 'gun/lib/open.js';
+import Logger from './Logger.js';
+import EventFilter from './EventFilter.js';
+import Paginator from './Paginator.js';
+import DataCompressor from './DataCompressor.js';
+
+/**
+ * EventStore - Handles Gun.js data storage operations
+ */
+export default class EventStore {
+    constructor(gunConfig, retryOperation, networkManager = null) {
+        this.gun = Gun(gunConfig);
+        this.retryOperation = retryOperation;
+        this.networkManager = networkManager;
+        this.logger = new Logger({
+            context: 'EventStore',
+            level: gunConfig?.logLevel || 'info'
+        });
+        
+        // Initialize components
+        this.eventFilter = new EventFilter(this.logger);
+        this.paginator = new Paginator(this.logger);
+        this.dataCompressor = new DataCompressor(this.logger);
+        
+        // Compression settings
+        this.compressionEnabled = gunConfig?.compression?.enabled ?? true;
+        this.compressionStrategy = gunConfig?.compression?.strategy ?? 'optimized';
+
+        // Track active Gun listeners for cleanup
+        this._activeListeners = [];
+        
+        this.logger.info('EventStore initialized', {
+            gunConfig: this._sanitizeGunConfig(gunConfig),
+            compressionEnabled: this.compressionEnabled,
+            compressionStrategy: this.compressionStrategy
+        });
+    }
+
+    // Sanitize Gun config for logging
+    _sanitizeGunConfig(config) {
+        if (!config || typeof config !== 'object') return config;
+        // Remove potentially sensitive information
+        const sanitized = { ...config };
+        delete sanitized.peers;
+        delete sanitized.localStorage;
+        return sanitized;
+    }
+
+    // Get the start block number for syncing events from the blockchain
+    async getStartBlockNumber() {
+        return this.retryOperation(async () => {
+            return new Promise((resolve) => {
+                this.gun.get('config').get('startBlockNumber').once((data) => {
+                    resolve(data || 1);
+                });
+            });
+        }, 'Getting start block number');
+    }
+
+    // Set the start block number for syncing events from the blockchain
+    async setStartBlockNumber(startBlockNumber) {
+        return this.retryOperation(async () => {
+            return new Promise((resolve, reject) => {
+                this.gun.get('config').get('startBlockNumber').put(startBlockNumber, (ack) => {
+                    if (ack.err) {
+                        reject(new Error(ack.err));
+                    } else {
+                        resolve(ack);
+                    }
+                });
+            });
+        }, `Setting start block number to ${startBlockNumber}`);
+    }
+
+    // Store an event in the decentralized database
+    async storeEvent(eventName, eventKey, eventData) {
+        return this.logger.time('storeEvent', async () => {
+            this.logger.logDatabaseActivity('storeEvent', {
+                eventName,
+                eventKey,
+                blockNumber: eventData.blockNumber,
+                transactionHash: eventData.transactionHash
+            });
+            
+            // Compress data if enabled
+            let dataToStore = eventData;
+            if (this.compressionEnabled) {
+                const compressed = this.dataCompressor.compress(eventData, this.compressionStrategy);
+                dataToStore = {
+                    _compressed: true,
+                    _data: compressed.data,
+                    _metadata: compressed.metadata
+                };
+            }
+            
+            return this.retryOperation(
+                () => new Promise(resolve => {
+                    this.gun.get('events').get(eventName).get(eventKey).put(dataToStore, resolve);
+                }),
+                `Storing event ${eventName}`
+            );
+        }, { eventName, eventKey });
+    }
+
+    // Get events by name with optional filtering
+    async getEvents(eventName, filter = {}) {
+        return this.logger.time('getEvents', async () => {
+            this.logger.logDatabaseActivity('getEvents', {
+                eventName,
+                filter: Object.keys(filter)
+            });
+            
+            return this.retryOperation(async () => {
+                return new Promise((resolve) => {
+                    let resolved = false;
+                    const node = this.gun.get('events').get(eventName);
+
+                    const timeout = setTimeout(() => {
+                        if (!resolved) {
+                            resolved = true;
+                            this.logger.debug('getEvents timed out, returning empty', { eventName });
+                            resolve([]);
+                        }
+                    }, 3000);
+
+                    node.open((data) => {
+                        if (resolved) return;
+                        resolved = true;
+                        clearTimeout(timeout);
+
+                        const events = [];
+                        if (data && typeof data === 'object') {
+                            Object.entries(data).forEach(([key, value]) => {
+                                if (key === '_' || !value || typeof value !== 'object') return;
+                                if (this._matchesFilter(value, filter)) {
+                                    events.push({ key, ...value });
+                                }
+                            });
+                        }
+
+                        this.logger.debug('Events retrieved', {
+                            eventName,
+                            eventCount: events.length,
+                            filterApplied: Object.keys(filter).length > 0
+                        });
+                        resolve(events);
+                    });
+                });
+            }, `Getting events for ${eventName}`);
+        }, { eventName });
+    }
+
+    // Get all events with optional filtering and pagination
+    async getAllEvents(options = {}) {
+        return this.logger.time('getAllEvents', async () => {
+            const { filter = {}, pagination = {}, sort = {} } = options;
+            
+            // Get all events from Gun
+            const allEventsMap = await this._fetchAllEventsMap();
+            
+            // Flatten events into array
+            const allEvents = [];
+            Object.entries(allEventsMap).forEach(([eventName, events]) => {
+                events.forEach(event => {
+                    allEvents.push({
+                        ...event,
+                        eventName
+                    });
+                });
+            });
+            
+            // Apply filters
+            let filteredEvents = allEvents;
+            if (Object.keys(filter).length > 0) {
+                const filterCriteria = this.eventFilter.buildFilter(filter);
+                filteredEvents = this.eventFilter.applyFilter(allEvents, filterCriteria);
+            }
+            
+            // Apply sorting
+            if (sort.by) {
+                filteredEvents = this.eventFilter.sortEvents(filteredEvents, sort);
+            }
+            
+            // Apply pagination
+            if (pagination.page || pagination.pageSize) {
+                const paginatedResult = this.paginator.paginate(filteredEvents, pagination);
+                this.logger.debug('Query completed', {
+                    totalEvents: allEvents.length,
+                    filteredEvents: filteredEvents.length,
+                    returnedEvents: paginatedResult.data.length
+                });
+                return paginatedResult;
+            }
+            
+            // Return unpaginated results
+            return {
+                data: filteredEvents,
+                meta: {
+                    totalItems: filteredEvents.length
+                }
+            };
+        });
+    }
+
+    // Internal method to fetch all events as a map
+    async _fetchAllEventsMap() {
+        return this.retryOperation(async () => {
+            return new Promise((resolve) => {
+                let resolved = false;
+                const node = this.gun.get('events');
+
+                const timeout = setTimeout(() => {
+                    if (!resolved) {
+                        resolved = true;
+                        this.logger.debug('_fetchAllEventsMap timed out, returning empty');
+                        resolve({});
+                    }
+                }, 5000);
+
+                node.open((data) => {
+                    if (resolved) return;
+                    resolved = true;
+                    clearTimeout(timeout);
+
+                    const allEvents = {};
+                    if (data && typeof data === 'object') {
+                        Object.entries(data).forEach(([eventName, eventGroup]) => {
+                            if (eventName === '_' || !eventGroup || typeof eventGroup !== 'object') return;
+                            allEvents[eventName] = [];
+                            Object.entries(eventGroup).forEach(([key, eventData]) => {
+                                if (key === '_' || !eventData || typeof eventData !== 'object') return;
+                                let decompressed = eventData;
+                                if (eventData._compressed && eventData._data) {
+                                    try {
+                                        decompressed = this.dataCompressor.decompress({
+                                            data: eventData._data,
+                                            metadata: eventData._metadata
+                                        });
+                                    } catch (error) {
+                                        this.logger.error('Failed to decompress event', {
+                                            eventName,
+                                            key,
+                                            error: error.message
+                                        });
+                                    }
+                                }
+                                allEvents[eventName].push({ key, ...decompressed });
+                            });
+                        });
+                    }
+                    resolve(allEvents);
+                });
+            });
+        }, 'Getting all events');
+    }
+
+    // Publish magazine metadata to the decentralized network
+    async publishMagazine(alias, magazineData, url) {
+        return this.logger.time('publishMagazine', async () => {
+            this.logger.info('Publishing magazine', {
+                alias,
+                url,
+                magazineData: {
+                    name: magazineData.name,
+                    address: magazineData.address,
+                    networkId: magazineData.networkId
+                }
+            });
+            
+            return this.retryOperation(async () => {
+                const magazineNode = this.gun.back(-1).get(alias);
+                
+                const magazineId = await new Promise((resolve, reject) => {
+                    magazineNode.put(magazineData, (ack) => {
+                        if (ack.err) {
+                            this.logger.error('Failed to publish magazine metadata', {
+                                alias,
+                                error: ack.err
+                            });
+                            reject(new Error(ack.err));
+                        } else {
+                            this.logger.debug('Magazine metadata published', { alias });
+                            resolve(ack);
+                        }
+                    });
+                });
+                
+                await new Promise((resolve, reject) => {
+                    magazineNode.get('url').put(url, (ack) => {
+                        if (ack.err) {
+                            this.logger.error('Failed to publish magazine URL', {
+                                alias,
+                                url,
+                                error: ack.err
+                            });
+                            reject(new Error(ack.err));
+                        } else {
+                            this.logger.debug('Magazine URL published', { alias, url });
+                            resolve(ack);
+                        }
+                    });
+                });
+
+                this.logger.info('Magazine published successfully', { alias, url });
+                return magazineId;
+            }, 'Publishing magazine');
+        }, { alias });
+    }
+
+    // Subscribe to a magazine on the decentralized network
+    async subscribeMagazine(magazineId) {
+        return this.retryOperation(async () => {
+            return new Promise((resolve, reject) => {
+                this.gun.get(magazineId).once((data, key) => {
+                    if (data) {
+                        resolve(data);
+                    } else {
+                        reject(new Error(`Magazine with ID ${magazineId} not found`));
+                    }
+                });
+            });
+        }, `Subscribing to magazine ${magazineId}`);
+    }
+
+    // Helper method to check if event data matches filter criteria
+    _matchesFilter(data, filter) {
+        if (!filter || Object.keys(filter).length === 0) {
+            return true;
+        }
+
+        for (const [key, value] of Object.entries(filter)) {
+            if (data[key] !== value) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    // Query events using fluent API
+    async query() {
+        const allEventsMap = await this._fetchAllEventsMap();
+        
+        // Flatten events
+        const allEvents = [];
+        Object.entries(allEventsMap).forEach(([eventName, events]) => {
+            events.forEach(event => {
+                allEvents.push({
+                    ...event,
+                    eventName
+                });
+            });
+        });
+        
+        return this.eventFilter.query(allEvents);
+    }
+
+    // Get events by transaction hash
+    async getEventsByTransactionHash(transactionHash) {
+        return this.logger.time('getEventsByTransactionHash', async () => {
+            const result = await this.getAllEvents({
+                filter: { transactionHash }
+            });
+            
+            this.logger.debug('Found events by transaction hash', {
+                transactionHash,
+                count: result.data.length
+            });
+            
+            return result.data;
+        });
+    }
+
+    // Get events by block number
+    async getEventsByBlockNumber(blockNumber) {
+        return this.logger.time('getEventsByBlockNumber', async () => {
+            const result = await this.getAllEvents({
+                filter: {
+                    fromBlock: blockNumber,
+                    toBlock: blockNumber
+                }
+            });
+            
+            this.logger.debug('Found events by block number', {
+                blockNumber,
+                count: result.data.length
+            });
+            
+            return result.data;
+        });
+    }
+
+    // Create async iterator for events
+    async *iterateEvents(options = {}) {
+        const { filter = {}, sort = {}, pageSize = 100 } = options;
+        
+        // Get filtered and sorted events
+        const result = await this.getAllEvents({ filter, sort });
+        const events = result.data;
+        
+        // Use paginator's iterator
+        yield* this.paginator.iterate(events, { pageSize });
+    }
+
+    // Get compression statistics
+    async getCompressionStats() {
+        const allEventsMap = await this._fetchAllEventsMap();
+        let totalOriginal = 0;
+        let totalCompressed = 0;
+        let compressedCount = 0;
+        
+        Object.values(allEventsMap).forEach(events => {
+            events.forEach(event => {
+                if (event._compressed && event._metadata) {
+                    totalOriginal += event._metadata.originalSize || 0;
+                    totalCompressed += event._metadata.compressedSize || 0;
+                    compressedCount++;
+                }
+            });
+        });
+        
+        return {
+            compressedEvents: compressedCount,
+            totalOriginalSize: totalOriginal,
+            totalCompressedSize: totalCompressed,
+            compressionRatio: totalOriginal > 0 ? (totalCompressed / totalOriginal).toFixed(3) : '1.000',
+            spaceSaved: totalOriginal > 0 ? `${((1 - totalCompressed / totalOriginal) * 100).toFixed(1)}%` : '0%'
+        };
+    }
+
+    // Clean up all active listeners
+    destroy() {
+        this._activeListeners = [];
+        this.logger.info('EventStore destroyed, listeners cleaned up');
+    }
+
+    // Get Gun instance for advanced operations
+    getGunInstance() {
+        return this.gun;
+    }
+}