resig.js/build/module/streaming/event-sourcing.js

Universal reactive signal library with complete platform features: signals, animations, CRDTs, scheduling, DOM integration. Works identically across React, SolidJS, Svelte, Vue, and Qwik.

/**
 * Event Sourcing with CRDTs
 * Complete state reconstruction with event replay, snapshots, and compaction
 */
import { gCounter, orSet } from '../crdt';
import { createStreamingSignal } from './coalgebra';
// In-memory event store implementation
export class MemoryEventStore {
    constructor() {
        this.events = [];
        this.snapshots = [];
    }
    async append(events) {
        this.events.push(...events);
        this.events.sort((a, b) => a.version - b.version);
    }
    async getEvents(fromVersion = 0, toVersion = Infinity) {
        return this.events.filter((e) => e.version >= fromVersion && e.version <= toVersion);
    }
    async getSnapshot(beforeVersion = Infinity) {
        const validSnapshots = this.snapshots.filter((s) => s.version < beforeVersion);
        return validSnapshots.length > 0
            ? validSnapshots[validSnapshots.length - 1]
            : null;
    }
    async saveSnapshot(snapshot) {
        this.snapshots.push(snapshot);
        this.snapshots.sort((a, b) => a.version - b.version);
    }
    async compact(beforeVersion) {
        this.events = this.events.filter((e) => e.version >= beforeVersion);
        this.snapshots = this.snapshots.filter((s) => s.version >= beforeVersion);
    }
}
// IndexedDB event store for browser persistence
export class IndexedDBEventStore {
    constructor(dbName) {
        this.db = null;
        this.dbName = dbName;
    }
    async getDB() {
        if (this.db)
            return this.db;
        return new Promise((resolve, reject) => {
            const request = indexedDB.open(this.dbName, 1);
            request.onerror = () => reject(request.error);
            request.onsuccess = () => {
                this.db = request.result;
                resolve(this.db);
            };
            request.onupgradeneeded = () => {
                const db = request.result;
                if (!db.objectStoreNames.contains('events')) {
                    const eventStore = db.createObjectStore('events', { keyPath: 'id' });
                    eventStore.createIndex('version', 'version', { unique: false });
                    eventStore.createIndex('timestamp', 'timestamp', { unique: false });
                }
                if (!db.objectStoreNames.contains('snapshots')) {
                    const snapshotStore = db.createObjectStore('snapshots', {
                        keyPath: 'version',
                    });
                    snapshotStore.createIndex('timestamp', 'timestamp', {
                        unique: false,
                    });
                }
            };
        });
    }
    async append(events) {
        const db = await this.getDB();
        const transaction = db.transaction(['events'], 'readwrite');
        const store = transaction.objectStore('events');
        for (const event of events) {
            store.add(event);
        }
        return new Promise((resolve, reject) => {
            transaction.oncomplete = () => resolve();
            transaction.onerror = () => reject(transaction.error);
        });
    }
    async getEvents(fromVersion = 0, toVersion = Infinity) {
        const db = await this.getDB();
        const transaction = db.transaction(['events'], 'readonly');
        const store = transaction.objectStore('events');
        const index = store.index('version');
        const range = IDBKeyRange.bound(fromVersion, toVersion);
        const request = index.getAll(range);
        return new Promise((resolve, reject) => {
            request.onsuccess = () => resolve(request.result);
            request.onerror = () => reject(request.error);
        });
    }
    async getSnapshot(beforeVersion = Infinity) {
        const db = await this.getDB();
        const transaction = db.transaction(['snapshots'], 'readonly');
        const store = transaction.objectStore('snapshots');
        const range = IDBKeyRange.upperBound(beforeVersion, true);
        const request = store.openCursor(range, 'prev');
        return new Promise((resolve, reject) => {
            request.onsuccess = () => {
                const cursor = request.result;
                resolve(cursor ? cursor.value : null);
            };
            request.onerror = () => reject(request.error);
        });
    }
    async saveSnapshot(snapshot) {
        const db = await this.getDB();
        const transaction = db.transaction(['snapshots'], 'readwrite');
        const store = transaction.objectStore('snapshots');
        store.put(snapshot);
        return new Promise((resolve, reject) => {
            transaction.oncomplete = () => resolve();
            transaction.onerror = () => reject(transaction.error);
        });
    }
    async compact(beforeVersion) {
        const db = await this.getDB();
        const transaction = db.transaction(['events', 'snapshots'], 'readwrite');
        // Remove old events
        const eventStore = transaction.objectStore('events');
        const eventIndex = eventStore.index('version');
        const eventRange = IDBKeyRange.upperBound(beforeVersion, true);
        const eventRequest = eventIndex.openCursor(eventRange);
        eventRequest.onsuccess = () => {
            const cursor = eventRequest.result;
            if (cursor) {
                cursor.delete();
                cursor.continue();
            }
        };
        // Remove old snapshots
        const snapshotStore = transaction.objectStore('snapshots');
        const snapshotRange = IDBKeyRange.upperBound(beforeVersion, true);
        const snapshotRequest = snapshotStore.openCursor(snapshotRange);
        snapshotRequest.onsuccess = () => {
            const cursor = snapshotRequest.result;
            if (cursor) {
                cursor.delete();
                cursor.continue();
            }
        };
        return new Promise((resolve, reject) => {
            transaction.oncomplete = () => resolve();
            transaction.onerror = () => reject(transaction.error);
        });
    }
}
// Create event sourced CRDT wrapper
export const createEventSourcedCRDT = (baseCRDT, config, nodeId = Math.random().toString(36)) => {
    let version = 0;
    let eventCount = 0;
    const eventStream = createStreamingSignal(null);
    // Track pending events for batching
    const pendingEvents = [];
    let flushTimeout = null;
    const flushEvents = async () => {
        if (pendingEvents.length === 0)
            return;
        const eventsToFlush = [...pendingEvents];
        pendingEvents.length = 0;
        await config.eventStore.append(eventsToFlush);
        // Check if we need to create a snapshot
        if (eventCount % config.snapshotInterval === 0) {
            await createSnapshot();
        }
        // Check if we need to compact
        await checkCompaction();
    };
    const createSnapshot = async () => {
        const snapshot = {
            timestamp: Date.now(),
            version,
            state: baseCRDT.value(),
            eventCount,
            checksum: generateChecksum(baseCRDT.value()),
        };
        await config.eventStore.saveSnapshot(snapshot);
        return snapshot;
    };
    const checkCompaction = async () => {
        const { compactionStrategy, maxEvents, maxAge } = config;
        switch (compactionStrategy) {
            case 'event-count':
                if (maxEvents && eventCount > maxEvents) {
                    const compactBefore = version - Math.floor(maxEvents / 2);
                    await config.eventStore.compact(compactBefore);
                }
                break;
            case 'time-based':
                if (maxAge) {
                    const cutoffTime = Date.now() - maxAge;
                    const events = await config.eventStore.getEvents();
                    const cutoffVersion = events.find((e) => e.timestamp > cutoffTime)?.version || version;
                    await config.eventStore.compact(cutoffVersion);
                }
                break;
            case 'sliding-window':
                if (maxEvents && eventCount > maxEvents) {
                    await config.eventStore.compact(version - maxEvents);
                }
                break;
        }
    };
    const generateChecksum = (state) => {
        return btoa(JSON.stringify(state)).slice(0, 16);
    };
    const addEvent = (event) => {
        const fullEvent = {
            ...event,
            id: `${nodeId}-${Date.now()}-${Math.random().toString(36)}`,
            version: ++version,
            nodeId,
            timestamp: Date.now(),
        };
        pendingEvents.push(fullEvent);
        eventCount++;
        // Emit event immediately
        eventStream._set(fullEvent);
        // Batch flush events
        if (flushTimeout)
            clearTimeout(flushTimeout);
        flushTimeout = (typeof window !== 'undefined' ? window.setTimeout : setTimeout)(flushEvents, 10);
    };
    const eventSourcedCRDT = {
        value: baseCRDT.value,
        merge: (other) => {
            const merged = baseCRDT.merge(other);
            addEvent({ type: 'merge', data: other.value() });
            return merged;
        },
        events: () => eventStream,
        replayFrom: async (timestamp) => {
            // Get the latest snapshot before the timestamp
            const snapshot = await config.eventStore.getSnapshot();
            const state = snapshot ? snapshot.state : baseCRDT.value();
            // Get events from snapshot version or beginning
            const fromVersion = snapshot ? snapshot.version : 0;
            const events = await config.eventStore.getEvents(fromVersion);
            // Filter events by timestamp and replay
            events.filter((e) => e.timestamp >= timestamp);
            // This is a simplified replay - in practice, you'd need to apply events to recreate state
            // For now, we return the current state
            return state;
        },
        snapshot: createSnapshot,
        compact: async () => {
            await createSnapshot();
            await config.eventStore.compact(version - config.snapshotInterval);
        },
        getEventCount: () => eventCount,
        getVersion: () => version,
        clone: () => {
            return createEventSourcedCRDT(baseCRDT, config, nodeId);
        },
        toJSON: () => {
            return {
                value: baseCRDT.value(),
                version,
                eventCount,
                nodeId,
            };
        },
        fromJSON: (data) => {
            return createEventSourcedCRDT(baseCRDT, config, data.nodeId || nodeId);
        },
    };
    // Wrap original CRDT methods to emit events
    const originalMethods = Object.getOwnPropertyNames(Object.getPrototypeOf(baseCRDT));
    originalMethods.forEach((methodName) => {
        if (typeof baseCRDT[methodName] === 'function' &&
            methodName !== 'value' &&
            methodName !== 'merge') {
            const originalMethod = baseCRDT[methodName];
            eventSourcedCRDT[methodName] = (...args) => {
                const result = originalMethod.apply(baseCRDT, args);
                addEvent({ type: methodName, data: args });
                return result;
            };
        }
    });
    return eventSourcedCRDT;
};
// Convenience functions for common CRDT types
export const eventSourcedORSet = (nodeId, config) => {
    return createEventSourcedCRDT(orSet(nodeId), config, nodeId);
};
export const eventSourcedGCounter = (nodeId, config) => {
    return createEventSourcedCRDT(gCounter(nodeId), config, nodeId);
};
export const indexedDBEventStore = (dbName) => new IndexedDBEventStore(dbName);
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event-sourcing.js","sourceRoot":"","sources":["../../../src/streaming/event-sourcing.ts"],"names":[],"mappings":"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"}