@monygroupcorp/micro-web3 0.1.3 → 1.2.1

package/src/storage/IndexedDBAdapter.js

@@ -0,0 +1,423 @@
+// src/storage/IndexedDBAdapter.js
+
+import StorageAdapter from './StorageAdapter.js';
+
+/**
+ * IndexedDB storage adapter for EventIndexer.
+ * Provides persistent event storage with auto-generated indexes.
+ */
+class IndexedDBAdapter extends StorageAdapter {
+  constructor() {
+    super();
+    this.db = null;
+    this.config = null;
+    this.dbName = null;
+  }
+
+  async initialize(config) {
+    this.config = config;
+    this.dbName = config.dbName;
+
+    // Check for existing version
+    const existingVersion = await this._getStoredVersion();
+
+    // Handle migration: if config version is higher, we need to clear and rebuild
+    const needsMigration = existingVersion !== null && config.version > existingVersion;
+
+    if (needsMigration) {
+      console.log(`[IndexedDBAdapter] Migrating from v${existingVersion} to v${config.version}`);
+      await this._deleteDatabase();
+    }
+
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.dbName, config.version);
+
+      request.onerror = () => {
+        reject(new Error(`Failed to open IndexedDB: ${request.error?.message}`));
+      };
+
+      request.onsuccess = () => {
+        this.db = request.result;
+        resolve();
+      };
+
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        this._createStores(db, config.eventTypes);
+      };
+    });
+  }
+
+  _createStores(db, eventTypes) {
+    // Create store for each event type
+    for (const eventType of eventTypes) {
+      const storeName = `events_${eventType.name}`;
+
+      if (!db.objectStoreNames.contains(storeName)) {
+        const store = db.createObjectStore(storeName, { keyPath: 'id' });
+
+        // Create indexes for indexed params (from ABI)
+        for (const param of eventType.indexedParams || []) {
+          store.createIndex(`param_${param}`, `indexed.${param}`, { unique: false });
+        }
+
+        // Always create blockNumber and timestamp indexes
+        store.createIndex('blockNumber', 'blockNumber', { unique: false });
+        store.createIndex('timestamp', 'timestamp', { unique: false });
+      }
+    }
+
+    // Create sync state store
+    if (!db.objectStoreNames.contains('syncState')) {
+      db.createObjectStore('syncState', { keyPath: 'id' });
+    }
+
+    // Create meta store for version tracking
+    if (!db.objectStoreNames.contains('meta')) {
+      db.createObjectStore('meta', { keyPath: 'key' });
+    }
+  }
+
+  async _getStoredVersion() {
+    return new Promise((resolve) => {
+      const request = indexedDB.open(this.dbName);
+      request.onsuccess = () => {
+        const db = request.result;
+        const version = db.version;
+        db.close();
+        resolve(version);
+      };
+      request.onerror = () => resolve(null);
+    });
+  }
+
+  async _deleteDatabase() {
+    return new Promise((resolve, reject) => {
+      if (this.db) {
+        this.db.close();
+        this.db = null;
+      }
+      const request = indexedDB.deleteDatabase(this.dbName);
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+    });
+  }
+
+  async putEvents(events) {
+    if (!this.db) throw new Error('IndexedDBAdapter not initialized');
+    if (events.length === 0) return;
+
+    // Group events by type for batch operations
+    const eventsByType = new Map();
+    for (const event of events) {
+      if (!eventsByType.has(event.type)) {
+        eventsByType.set(event.type, []);
+      }
+      eventsByType.get(event.type).push(event);
+    }
+
+    // Write each type in a transaction
+    const promises = [];
+    for (const [type, typeEvents] of eventsByType) {
+      promises.push(this._putEventsOfType(type, typeEvents));
+    }
+    await Promise.all(promises);
+  }
+
+  async _putEventsOfType(type, events) {
+    const storeName = `events_${type}`;
+
+    // Check if store exists, create if needed
+    if (!this.db.objectStoreNames.contains(storeName)) {
+      // Need to reopen with version upgrade to add new store
+      await this._addStore(type);
+    }
+
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction(storeName, 'readwrite');
+      const store = tx.objectStore(storeName);
+
+      for (const event of events) {
+        store.put(event);
+      }
+
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+
+  async _addStore(eventType) {
+    // Close current connection
+    const currentVersion = this.db.version;
+    this.db.close();
+
+    // Reopen with incremented version
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.dbName, currentVersion + 1);
+
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        const storeName = `events_${eventType}`;
+        if (!db.objectStoreNames.contains(storeName)) {
+          const store = db.createObjectStore(storeName, { keyPath: 'id' });
+          store.createIndex('blockNumber', 'blockNumber', { unique: false });
+          store.createIndex('timestamp', 'timestamp', { unique: false });
+        }
+      };
+
+      request.onsuccess = () => {
+        this.db = request.result;
+        resolve();
+      };
+
+      request.onerror = () => reject(request.error);
+    });
+  }
+
+  async getEvent(type, id) {
+    if (!this.db) throw new Error('IndexedDBAdapter not initialized');
+
+    const storeName = `events_${type}`;
+    if (!this.db.objectStoreNames.contains(storeName)) {
+      return null;
+    }
+
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction(storeName, 'readonly');
+      const store = tx.objectStore(storeName);
+      const request = store.get(id);
+
+      request.onsuccess = () => resolve(request.result || null);
+      request.onerror = () => reject(request.error);
+    });
+  }
+
+  async queryEvents(type, options = {}) {
+    if (!this.db) throw new Error('IndexedDBAdapter not initialized');
+
+    const storeName = `events_${type}`;
+    if (!this.db.objectStoreNames.contains(storeName)) {
+      return { events: [], total: 0, hasMore: false };
+    }
+
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction(storeName, 'readonly');
+      const store = tx.objectStore(storeName);
+
+      // Get all events (we'll filter/sort in memory for complex queries)
+      // For simple indexed queries, we could use IDB indexes, but this is more flexible
+      const request = store.getAll();
+
+      request.onsuccess = () => {
+        let events = request.result;
+
+        // Apply where filters
+        if (options.where) {
+          events = events.filter(event => this._matchesWhere(event, options.where));
+        }
+
+        const total = events.length;
+
+        // Sort
+        const orderBy = options.orderBy || 'blockNumber';
+        const order = options.order || 'desc';
+        events.sort((a, b) => {
+          const aVal = this._getNestedValue(a, orderBy);
+          const bVal = this._getNestedValue(b, orderBy);
+          if (aVal < bVal) return order === 'asc' ? -1 : 1;
+          if (aVal > bVal) return order === 'asc' ? 1 : -1;
+          return 0;
+        });
+
+        // Pagination
+        const offset = options.offset || 0;
+        const limit = options.limit || 100;
+        const paged = events.slice(offset, offset + limit);
+
+        resolve({
+          events: paged,
+          total,
+          hasMore: offset + limit < total
+        });
+      };
+
+      request.onerror = () => reject(request.error);
+    });
+  }
+
+  async countEvents(type, where) {
+    if (!this.db) throw new Error('IndexedDBAdapter not initialized');
+
+    const storeName = `events_${type}`;
+    if (!this.db.objectStoreNames.contains(storeName)) {
+      return 0;
+    }
+
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction(storeName, 'readonly');
+      const store = tx.objectStore(storeName);
+
+      if (!where) {
+        const request = store.count();
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+      } else {
+        // Need to filter manually
+        const request = store.getAll();
+        request.onsuccess = () => {
+          const count = request.result.filter(e => this._matchesWhere(e, where)).length;
+          resolve(count);
+        };
+        request.onerror = () => reject(request.error);
+      }
+    });
+  }
+
+  async deleteEvents(type, ids) {
+    if (!this.db) throw new Error('IndexedDBAdapter not initialized');
+
+    const storeName = `events_${type}`;
+    if (!this.db.objectStoreNames.contains(storeName)) return;
+
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction(storeName, 'readwrite');
+      const store = tx.objectStore(storeName);
+
+      for (const id of ids) {
+        store.delete(id);
+      }
+
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+
+  async deleteEventsAfterBlock(blockNumber) {
+    if (!this.db) throw new Error('IndexedDBAdapter not initialized');
+
+    const storeNames = Array.from(this.db.objectStoreNames)
+      .filter(name => name.startsWith('events_'));
+
+    for (const storeName of storeNames) {
+      await this._deleteEventsAfterBlockInStore(storeName, blockNumber);
+    }
+  }
+
+  async _deleteEventsAfterBlockInStore(storeName, blockNumber) {
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction(storeName, 'readwrite');
+      const store = tx.objectStore(storeName);
+      const index = store.index('blockNumber');
+      const range = IDBKeyRange.lowerBound(blockNumber, true); // exclusive
+
+      const request = index.openCursor(range);
+      request.onsuccess = (event) => {
+        const cursor = event.target.result;
+        if (cursor) {
+          cursor.delete();
+          cursor.continue();
+        }
+      };
+
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+
+  async getSyncState() {
+    if (!this.db) throw new Error('IndexedDBAdapter not initialized');
+
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction('syncState', 'readonly');
+      const store = tx.objectStore('syncState');
+      const request = store.get('current');
+
+      request.onsuccess = () => resolve(request.result || null);
+      request.onerror = () => reject(request.error);
+    });
+  }
+
+  async setSyncState(state) {
+    if (!this.db) throw new Error('IndexedDBAdapter not initialized');
+
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction('syncState', 'readwrite');
+      const store = tx.objectStore('syncState');
+      const request = store.put({ id: 'current', ...state });
+
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+    });
+  }
+
+  async getVersion() {
+    if (!this.db) return 0;
+    return this.db.version;
+  }
+
+  async setVersion(version) {
+    // Version is managed by IndexedDB upgrade mechanism
+    // This is a no-op, included for interface compliance
+  }
+
+  async clear() {
+    if (!this.db) return;
+
+    const storeNames = Array.from(this.db.objectStoreNames);
+
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction(storeNames, 'readwrite');
+
+      for (const storeName of storeNames) {
+        tx.objectStore(storeName).clear();
+      }
+
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+
+  async close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+
+  // Same helpers as MemoryAdapter
+  _matchesWhere(event, where) {
+    for (const [key, value] of Object.entries(where)) {
+      const eventValue = this._getNestedValue(event, key);
+
+      if (Array.isArray(value)) {
+        if (!value.includes(eventValue)) return false;
+      } else if (typeof value === 'object' && value !== null) {
+        if (value.$gt !== undefined && !(eventValue > value.$gt)) return false;
+        if (value.$gte !== undefined && !(eventValue >= value.$gte)) return false;
+        if (value.$lt !== undefined && !(eventValue < value.$lt)) return false;
+        if (value.$lte !== undefined && !(eventValue <= value.$lte)) return false;
+        if (value.$ne !== undefined && eventValue === value.$ne) return false;
+      } else {
+        const normalizedEvent = typeof eventValue === 'string' ? eventValue.toLowerCase() : eventValue;
+        const normalizedValue = typeof value === 'string' ? value.toLowerCase() : value;
+        if (normalizedEvent !== normalizedValue) return false;
+      }
+    }
+    return true;
+  }
+
+  _getNestedValue(obj, path) {
+    if (path.startsWith('indexed.')) {
+      return obj.indexed?.[path.slice(8)];
+    }
+    if (path.startsWith('data.')) {
+      return obj.data?.[path.slice(5)];
+    }
+
+    if (obj.indexed?.[path] !== undefined) return obj.indexed[path];
+    if (obj.data?.[path] !== undefined) return obj.data[path];
+    return obj[path];
+  }
+}
+
+export default IndexedDBAdapter;

package/src/storage/IndexerSettings.js

@@ -0,0 +1,88 @@
+// src/storage/IndexerSettings.js
+
+/**
+ * User preferences for EventIndexer storage.
+ * Persisted in localStorage.
+ */
+const STORAGE_KEY = 'mw3_indexer_settings';
+
+const IndexerSettings = {
+  /**
+   * Get all settings.
+   * @returns {Object}
+   */
+  get() {
+    try {
+      const stored = localStorage.getItem(STORAGE_KEY);
+      return stored ? JSON.parse(stored) : this.getDefaults();
+    } catch {
+      return this.getDefaults();
+    }
+  },
+
+  /**
+   * Get default settings.
+   * @returns {Object}
+   */
+  getDefaults() {
+    return {
+      storageEnabled: true,  // Allow IndexedDB storage
+      maxStorageMB: 50,      // Max storage in MB (0 = unlimited)
+    };
+  },
+
+  /**
+   * Update settings.
+   * @param {Object} updates - Partial settings to update
+   */
+  set(updates) {
+    const current = this.get();
+    const updated = { ...current, ...updates };
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(updated));
+    return updated;
+  },
+
+  /**
+   * Check if IndexedDB storage is enabled.
+   * @returns {boolean}
+   */
+  isStorageEnabled() {
+    return this.get().storageEnabled;
+  },
+
+  /**
+   * Clear all indexer data from IndexedDB.
+   * @returns {Promise<void>}
+   */
+  async clearAllData() {
+    // Find and delete all micro-web3 databases
+    if (typeof indexedDB === 'undefined') return;
+
+    const databases = await indexedDB.databases?.() || [];
+    const mw3Databases = databases.filter(db =>
+      db.name?.startsWith('micro-web3-events-') ||
+      db.name?.includes('colasseum-')
+    );
+
+    for (const db of mw3Databases) {
+      await new Promise((resolve, reject) => {
+        const request = indexedDB.deleteDatabase(db.name);
+        request.onsuccess = resolve;
+        request.onerror = reject;
+      });
+    }
+  },
+
+  /**
+   * Estimate current storage usage.
+   * @returns {Promise<{used: number, quota: number}>} Bytes
+   */
+  async getStorageEstimate() {
+    if (navigator.storage?.estimate) {
+      return navigator.storage.estimate();
+    }
+    return { used: 0, quota: 0 };
+  }
+};
+
+export default IndexerSettings;

package/src/storage/MemoryAdapter.js

@@ -0,0 +1,194 @@
+// src/storage/MemoryAdapter.js
+
+import StorageAdapter from './StorageAdapter.js';
+
+/**
+ * In-memory storage adapter for EventIndexer.
+ * Used as fallback when IndexedDB unavailable (SSR, private browsing).
+ * No persistence across sessions.
+ */
+class MemoryAdapter extends StorageAdapter {
+  constructor() {
+    super();
+    this.stores = new Map(); // eventType -> Map<id, event>
+    this.syncState = null;
+    this.version = 0;
+    this.config = null;
+  }
+
+  async initialize(config) {
+    this.config = config;
+
+    // Create store for each event type
+    for (const eventType of config.eventTypes) {
+      this.stores.set(eventType.name, new Map());
+    }
+
+    // Check version for migration
+    if (config.version > this.version) {
+      await this.clear();
+      this.version = config.version;
+    }
+  }
+
+  async putEvents(events) {
+    for (const event of events) {
+      const store = this.stores.get(event.type);
+      if (!store) {
+        // Lazily create store for unknown event types
+        this.stores.set(event.type, new Map());
+      }
+      this.stores.get(event.type).set(event.id, event);
+    }
+  }
+
+  async getEvent(type, id) {
+    const store = this.stores.get(type);
+    if (!store) return null;
+    return store.get(id) || null;
+  }
+
+  async queryEvents(type, options = {}) {
+    const store = this.stores.get(type);
+    if (!store) {
+      return { events: [], total: 0, hasMore: false };
+    }
+
+    let events = Array.from(store.values());
+
+    // Apply where filters
+    if (options.where) {
+      events = events.filter(event => this._matchesWhere(event, options.where));
+    }
+
+    const total = events.length;
+
+    // Sort
+    const orderBy = options.orderBy || 'blockNumber';
+    const order = options.order || 'desc';
+    events.sort((a, b) => {
+      const aVal = this._getNestedValue(a, orderBy);
+      const bVal = this._getNestedValue(b, orderBy);
+      if (aVal < bVal) return order === 'asc' ? -1 : 1;
+      if (aVal > bVal) return order === 'asc' ? 1 : -1;
+      return 0;
+    });
+
+    // Pagination
+    const offset = options.offset || 0;
+    const limit = options.limit || 100;
+    const paged = events.slice(offset, offset + limit);
+
+    return {
+      events: paged,
+      total,
+      hasMore: offset + limit < total
+    };
+  }
+
+  async countEvents(type, where) {
+    const store = this.stores.get(type);
+    if (!store) return 0;
+
+    if (!where) return store.size;
+
+    let count = 0;
+    for (const event of store.values()) {
+      if (this._matchesWhere(event, where)) {
+        count++;
+      }
+    }
+    return count;
+  }
+
+  async deleteEvents(type, ids) {
+    const store = this.stores.get(type);
+    if (!store) return;
+
+    for (const id of ids) {
+      store.delete(id);
+    }
+  }
+
+  async deleteEventsAfterBlock(blockNumber) {
+    for (const store of this.stores.values()) {
+      for (const [id, event] of store.entries()) {
+        if (event.blockNumber > blockNumber) {
+          store.delete(id);
+        }
+      }
+    }
+  }
+
+  async getSyncState() {
+    return this.syncState;
+  }
+
+  async setSyncState(state) {
+    this.syncState = { ...state };
+  }
+
+  async getVersion() {
+    return this.version;
+  }
+
+  async setVersion(version) {
+    this.version = version;
+  }
+
+  async clear() {
+    for (const store of this.stores.values()) {
+      store.clear();
+    }
+    this.syncState = null;
+  }
+
+  async close() {
+    // No-op for memory adapter
+  }
+
+  // Helper: check if event matches where clause
+  _matchesWhere(event, where) {
+    for (const [key, value] of Object.entries(where)) {
+      const eventValue = this._getNestedValue(event, key);
+
+      // Handle array values (OR condition)
+      if (Array.isArray(value)) {
+        if (!value.includes(eventValue)) return false;
+      }
+      // Handle comparison operators
+      else if (typeof value === 'object' && value !== null) {
+        if (value.$gt !== undefined && !(eventValue > value.$gt)) return false;
+        if (value.$gte !== undefined && !(eventValue >= value.$gte)) return false;
+        if (value.$lt !== undefined && !(eventValue < value.$lt)) return false;
+        if (value.$lte !== undefined && !(eventValue <= value.$lte)) return false;
+        if (value.$ne !== undefined && eventValue === value.$ne) return false;
+      }
+      // Direct equality (case-insensitive for addresses)
+      else {
+        const normalizedEvent = typeof eventValue === 'string' ? eventValue.toLowerCase() : eventValue;
+        const normalizedValue = typeof value === 'string' ? value.toLowerCase() : value;
+        if (normalizedEvent !== normalizedValue) return false;
+      }
+    }
+    return true;
+  }
+
+  // Helper: get nested value from object using dot notation
+  _getNestedValue(obj, path) {
+    // Check indexed params first, then data, then direct
+    if (path.startsWith('indexed.')) {
+      return obj.indexed?.[path.slice(8)];
+    }
+    if (path.startsWith('data.')) {
+      return obj.data?.[path.slice(5)];
+    }
+
+    // Try indexed, then data, then direct property
+    if (obj.indexed?.[path] !== undefined) return obj.indexed[path];
+    if (obj.data?.[path] !== undefined) return obj.data[path];
+    return obj[path];
+  }
+}
+
+export default MemoryAdapter;