holosphere 2.0.0-alpha21 → 2.0.0-alpha23

package/src/storage/backends/gundb-backend.js

@@ -1,875 +0,0 @@
-/**
- * @fileoverview GunDB storage backend with authentication, schema validation, references, and global tables.
- * Provides full-featured P2P data storage using GunDB with write caching for immediate consistency.
- * @module storage/backends/gundb-backend
- */
-
-import { StorageBackend } from '../backend-interface.js';
-import * as wrapper from '../gun-wrapper.js';
-import { gunPromise, gunPut, gunMap, gunCollect } from '../gun-async.js';
-import { GunReferenceHandler } from '../gun-references.js';
-import { GunAuth } from '../gun-auth.js';
-import { GunSchemaValidator } from '../gun-schema.js';
-
-/**
- * GunDB storage backend implementation with advanced features.
- * Supports authentication, schema validation, references, global tables,
- * and write caching for immediate consistency.
- *
- * @class GunDBBackend
- * @extends StorageBackend
- * @example
- * const backend = await BackendFactory.create('gundb', {
- *   appName: 'myapp',
- *   peers: ['wss://gun-server.example.com/gun'],
- *   radisk: true
- * });
- */
-export class GunDBBackend extends StorageBackend {
-  /**
-   * Create a new GunDB backend instance.
-   * @param {Object} config - Backend configuration
-   * @param {string} [config.appName='holosphere'] - Application namespace
-   * @param {string[]} [config.peers=[]] - Array of peer URLs
-   * @param {boolean} [config.radisk=true] - Enable radisk persistence
-   * @param {boolean} [config.localStorage=true] - Enable localStorage
-   * @param {string} [config.dataDir='radata'] - Data directory for Node.js
-   * @param {string} [config.privateKey] - Optional existing private key
-   * @param {string} [config.publicKey] - Optional existing public key
-   * @param {boolean} [config.strict=false] - Enable strict schema validation
-   */
-  constructor(config) {
-    super(config);
-    this.gun = null;
-    this.keyPair = null;
-    this.appName = config.appName || 'holosphere';
-
-    // New modules
-    this.references = null;
-    this.auth = null;
-    this.schemaValidator = null;
-
-    // Subscription tracking
-    this.subscriptions = new Map();
-    this.subscriptionCounter = 0;
-
-    // Write cache for immediate consistency
-    // Gun's readAll/map().once() doesn't immediately see new writes - this cache bridges that gap
-    this.writeCache = new Map(); // path -> Map(id -> {data, timestamp})
-    this.writeCacheTTL = 300000; // Cache entries expire after 5 minutes (increased from 30s)
-
-    // Pending writes queue for retry
-    this.pendingWrites = new Map(); // path -> {data, retries, lastAttempt}
-    this.maxWriteRetries = 5;
-    this.writeRetryInterval = 10000; // 10 seconds between retries
-  }
-
-  async init() {
-    // Dynamically import Gun to avoid issues if not installed
-    let Gun;
-    try {
-      console.log('[gundb-backend] Importing Gun...');
-      const gunModule = await import('gun');
-      Gun = gunModule.default || gunModule;
-      console.log('[gundb-backend] Gun imported:', typeof Gun);
-    } catch (error) {
-      throw new Error(
-        'GunDB backend requires the "gun" package. Install it with: npm install gun'
-      );
-    }
-
-    // In Node.js, Gun needs a file path for radisk persistence
-    // Default to 'radata' if not specified
-    const dataDir = this.config.dataDir || 'radata';
-
-    const gunConfig = {
-      peers: this.config.peers || [],
-      radisk: this.config.radisk !== false,
-      localStorage: this.config.localStorage !== false,
-      file: dataDir,
-    };
-
-    console.log('[gundb-backend] Gun config:', JSON.stringify(gunConfig));
-
-    this.gun = Gun(gunConfig);
-    console.log('[gundb-backend] Gun instance created:', !!this.gun);
-
-    // Test basic Gun functionality
-    try {
-      const testKey = `_test_${Date.now()}`;
-      this.gun.get(testKey).put({ test: true }, (ack) => {
-        console.log('[gundb-backend] Gun test write ack:', ack);
-      });
-      console.log('[gundb-backend] Gun test write initiated');
-    } catch (e) {
-      console.error('[gundb-backend] Gun test write failed:', e.message);
-    }
-
-    // Add a small delay to let Gun initialize
-    await new Promise(resolve => setTimeout(resolve, 500));
-
-    // Generate or use provided key pair using Gun's SEA
-    try {
-      const SEA = Gun.SEA;
-      if (SEA) {
-        if (this.config.privateKey) {
-          // Try to restore from existing key
-          this.keyPair = { priv: this.config.privateKey, pub: this.config.publicKey };
-          this.publicKey = this.config.publicKey || this.config.privateKey.substring(0, 32);
-        } else {
-          // Generate new key pair
-          this.keyPair = await SEA.pair();
-          this.publicKey = this.keyPair.pub;
-        }
-      } else {
-        // SEA not available, use simple identifier
-        this.publicKey = this.appName;
-      }
-    } catch (error) {
-      // SEA might not be loaded
-      this.publicKey = this.appName;
-    }
-
-    // Initialize modules
-    this.references = new GunReferenceHandler(this.appName);
-    this.auth = new GunAuth(this.gun, this.appName);
-    this.schemaValidator = new GunSchemaValidator({
-      strict: this.config.strict || false,
-      cacheMaxAge: this.config.schemaCacheMaxAge || 3600000
-    });
-
-    // Try to initialize schema validator (may fail if AJV not installed)
-    await this.schemaValidator.init();
-  }
-
-  // ============================================================================
-  // WRITE CACHE (for immediate consistency)
-  // ============================================================================
-
-  /**
-   * Add item to the local write cache for immediate consistency
-   * @private
-   */
-  _addToWriteCache(path, data) {
-    if (!data || !data.id) return;
-
-    // Extract the parent path (without the data id)
-    const parentPath = path.substring(0, path.lastIndexOf('/'));
-    if (!parentPath) return;
-
-    if (!this.writeCache.has(parentPath)) {
-      this.writeCache.set(parentPath, new Map());
-    }
-
-    const pathCache = this.writeCache.get(parentPath);
-    pathCache.set(data.id.toString(), {
-      data: data,
-      timestamp: Date.now()
-    });
-  }
-
-  /**
-   * Remove item from write cache (e.g., on delete)
-   * @private
-   */
-  _removeFromWriteCache(path, id) {
-    // Extract the parent path
-    const parentPath = path.substring(0, path.lastIndexOf('/'));
-    const pathCache = this.writeCache.get(parentPath);
-    if (pathCache) {
-      pathCache.delete(id.toString());
-    }
-  }
-
-  /**
-   * Get cached writes for a path, filtering out expired entries
-   * @private
-   */
-  _getWriteCacheEntries(path) {
-    const pathCache = this.writeCache.get(path);
-    if (!pathCache) return [];
-
-    const now = Date.now();
-    const validEntries = [];
-
-    for (const [id, entry] of pathCache) {
-      if (now - entry.timestamp < this.writeCacheTTL) {
-        validEntries.push(entry.data);
-      } else {
-        // Clean up expired entries
-        pathCache.delete(id);
-      }
-    }
-
-    return validEntries;
-  }
-
-  /**
-   * Merge cached writes with results from Gun
-   * @private
-   */
-  _mergeWithWriteCache(path, gunResults) {
-    const cachedWrites = this._getWriteCacheEntries(path);
-    if (cachedWrites.length === 0) return gunResults;
-
-    // Create a map by ID for deduplication
-    const resultMap = new Map();
-
-    // Add Gun results first
-    for (const item of gunResults) {
-      if (item && item.id) {
-        resultMap.set(item.id.toString(), item);
-      }
-    }
-
-    // Overlay cached writes (they're more recent)
-    for (const item of cachedWrites) {
-      if (item && item.id && !item._deleted) {
-        resultMap.set(item.id.toString(), item);
-      } else if (item && item.id && item._deleted) {
-        // Remove deleted items
-        resultMap.delete(item.id.toString());
-      }
-    }
-
-    return Array.from(resultMap.values());
-  }
-
-  /**
-   * Clear write cache for a specific path or all paths
-   * @param {string} [path] - Optional path to clear, clears all if not provided
-   */
-  clearWriteCache(path = null) {
-    if (path) {
-      this.writeCache.delete(path);
-    } else {
-      this.writeCache.clear();
-    }
-  }
-
-  // ============================================================================
-  // PATH BUILDING
-  // ============================================================================
-
-  buildPath(appName, holonId, lensName, key = null) {
-    return wrapper.buildPath(appName, holonId, lensName, key);
-  }
-
-  buildGlobalPath(tableName, key = null) {
-    return wrapper.buildGlobalPath(this.appName, tableName, key);
-  }
-
-  // ============================================================================
-  // BASIC CRUD OPERATIONS
-  // ============================================================================
-
-  async write(path, data, options = {}) {
-    // Validate against schema if strict mode
-    if (this.schemaValidator && this.schemaValidator.isStrict()) {
-      const pathParts = path.split('/');
-      if (pathParts.length >= 3) {
-        const lens = pathParts[2];
-        // Skip validation for references
-        if (!this.isReference(data)) {
-          const result = await this.schemaValidator.validateData(
-            this.gun, this.appName, lens, data
-          );
-          if (!result.valid) {
-            throw new Error(`Schema validation failed: ${JSON.stringify(result.errors)}`);
-          }
-        }
-      }
-    }
-
-    // Add to write cache FIRST for immediate consistency
-    // This ensures readAll returns the new data even if Gun write is slow/times out
-    this._addToWriteCache(path, data);
-
-    // Try to write to Gun with retry on timeout
-    const result = await this._writeWithRetry(path, data);
-
-    return result;
-  }
-
-  /**
-   * Write to Gun with automatic retry on timeout
-   * @private
-   */
-  async _writeWithRetry(path, data, attempt = 0) {
-    const result = await wrapper.write(this.gun, path, data);
-
-    if (result.timeout && attempt < this.maxWriteRetries) {
-      // Queue for background retry
-      this.pendingWrites.set(path, {
-        data,
-        retries: attempt + 1,
-        lastAttempt: Date.now()
-      });
-
-      // Schedule retry
-      this._scheduleRetry(path);
-    } else if (!result.timeout) {
-      // Success - remove from pending
-      this.pendingWrites.delete(path);
-    }
-
-    return result;
-  }
-
-  /**
-   * Schedule a background retry for a pending write
-   * @private
-   */
-  _scheduleRetry(path) {
-    setTimeout(async () => {
-      const pending = this.pendingWrites.get(path);
-      if (!pending) return;
-
-      if (pending.retries >= this.maxWriteRetries) {
-        console.warn(`[gundb-backend] Max retries reached for: ${path}`);
-        this.pendingWrites.delete(path);
-        return;
-      }
-
-      console.log(`[gundb-backend] Retrying write (attempt ${pending.retries + 1}): ${path}`);
-      await this._writeWithRetry(path, pending.data, pending.retries);
-    }, this.writeRetryInterval);
-  }
-
-  async read(path, options = {}) {
-    const data = await wrapper.read(this.gun, path);
-
-    // Resolve references if requested
-    if (data && options.resolveReferences && this.isReference(data)) {
-      return this.resolveReference(data);
-    }
-
-    return data;
-  }
-
-  async readAll(path, options = {}) {
-    const gunItems = await wrapper.readAll(this.gun, path);
-
-    // Merge with write cache for immediate consistency
-    const items = this._mergeWithWriteCache(path, gunItems);
-
-    // Resolve references if requested
-    if (options.resolveReferences) {
-      const resolved = [];
-      for (const item of items) {
-        if (this.isReference(item)) {
-          const resolvedItem = await this.resolveReference(item);
-          if (resolvedItem) {
-            resolved.push(resolvedItem);
-          }
-        } else {
-          resolved.push(item);
-        }
-      }
-      return resolved;
-    }
-
-    return items;
-  }
-
-  async update(path, updates) {
-    return wrapper.update(this.gun, path, updates);
-  }
-
-  async delete(path) {
-    const result = await wrapper.deleteData(this.gun, path);
-
-    // Extract id from path and mark as deleted in cache
-    const pathParts = path.split('/');
-    const id = pathParts[pathParts.length - 1];
-    if (id) {
-      // Add tombstone to cache so readAll doesn't return this item
-      const parentPath = path.substring(0, path.lastIndexOf('/'));
-      if (!this.writeCache.has(parentPath)) {
-        this.writeCache.set(parentPath, new Map());
-      }
-      this.writeCache.get(parentPath).set(id.toString(), {
-        data: { id, _deleted: true },
-        timestamp: Date.now()
-      });
-    }
-
-    return result;
-  }
-
-  async deleteAll(path) {
-    const items = await this.readAll(path);
-    let count = 0;
-
-    for (const item of items) {
-      if (item && item.id) {
-        const itemPath = `${path}/${item.id}`;
-        await wrapper.deleteData(this.gun, itemPath);
-        count++;
-      }
-    }
-
-    return { success: true, count };
-  }
-
-  // ============================================================================
-  // GLOBAL TABLE OPERATIONS
-  // ============================================================================
-
-  async writeGlobal(tableName, data) {
-    // Add to write cache FIRST for immediate consistency
-    // This ensures readAllGlobal returns the new data even if Gun write is slow/times out
-    const path = this.buildGlobalPath(tableName, data.id);
-    this._addToWriteCache(path, data);
-
-    // Try to write to Gun with retry on timeout
-    const result = await this._writeGlobalWithRetry(tableName, data);
-
-    return result;
-  }
-
-  /**
-   * Write to global table with automatic retry on timeout
-   * @private
-   */
-  async _writeGlobalWithRetry(tableName, data, attempt = 0) {
-    const path = this.buildGlobalPath(tableName, data.id);
-    const result = await wrapper.writeGlobal(this.gun, this.appName, tableName, data);
-
-    if (result.timeout && attempt < this.maxWriteRetries) {
-      // Queue for background retry
-      this.pendingWrites.set(path, {
-        data: { tableName, data },
-        isGlobal: true,
-        retries: attempt + 1,
-        lastAttempt: Date.now()
-      });
-
-      // Schedule retry
-      this._scheduleGlobalRetry(path, tableName);
-    } else if (!result.timeout) {
-      // Success - remove from pending
-      this.pendingWrites.delete(path);
-    }
-
-    return result;
-  }
-
-  /**
-   * Schedule a background retry for a pending global write
-   * @private
-   */
-  _scheduleGlobalRetry(path, tableName) {
-    setTimeout(async () => {
-      const pending = this.pendingWrites.get(path);
-      if (!pending || !pending.isGlobal) return;
-
-      if (pending.retries >= this.maxWriteRetries) {
-        console.warn(`[gundb-backend] Max retries reached for global: ${path}`);
-        this.pendingWrites.delete(path);
-        return;
-      }
-
-      console.log(`[gundb-backend] Retrying global write (attempt ${pending.retries + 1}): ${path}`);
-      await this._writeGlobalWithRetry(tableName, pending.data.data, pending.retries);
-    }, this.writeRetryInterval);
-  }
-
-  async readGlobal(tableName, key) {
-    return wrapper.readGlobal(this.gun, this.appName, tableName, key);
-  }
-
-  async readAllGlobal(tableName, timeout = 5000) {
-    const gunItems = await wrapper.readAllGlobal(this.gun, this.appName, tableName, timeout);
-
-    // Merge with write cache for immediate consistency
-    const path = this.buildGlobalPath(tableName);
-    return this._mergeWithWriteCache(path, gunItems);
-  }
-
-  async deleteGlobal(tableName, key) {
-    const result = await wrapper.deleteGlobal(this.gun, this.appName, tableName, key);
-
-    // Mark as deleted in cache
-    const path = this.buildGlobalPath(tableName);
-    if (!this.writeCache.has(path)) {
-      this.writeCache.set(path, new Map());
-    }
-    this.writeCache.get(path).set(key.toString(), {
-      data: { id: key, _deleted: true },
-      timestamp: Date.now()
-    });
-
-    return result;
-  }
-
-  async deleteAllGlobal(tableName) {
-    return wrapper.deleteAllGlobal(this.gun, this.appName, tableName);
-  }
-
-  // ============================================================================
-  // REFERENCE OPERATIONS
-  // ============================================================================
-
-  /**
-   * Create a reference to data
-   */
-  createReference(holon, lens, data) {
-    return this.references.createReference(holon, lens, data);
-  }
-
-  /**
-   * Check if data is a reference
-   */
-  isReference(data) {
-    return this.references.isReference(data);
-  }
-
-  /**
-   * Resolve a reference to get actual data
-   */
-  async resolveReference(reference, options = {}) {
-    return this.references.resolveReference(this.gun, reference, options);
-  }
-
-  /**
-   * Parse a soul path
-   */
-  parseSoulPath(soul) {
-    return this.references.parseSoulPath(soul);
-  }
-
-  /**
-   * Get soul for data
-   */
-  getSoul(holon, lens, key) {
-    return this.references.getSoul(holon, lens, key);
-  }
-
-  // ============================================================================
-  // AUTHENTICATION OPERATIONS
-  // ============================================================================
-
-  /**
-   * Authenticate for a holon
-   */
-  async authenticate(holonId, password) {
-    return this.auth.authenticate(holonId, password);
-  }
-
-  /**
-   * Create a new user
-   */
-  async createUser(holonId, password) {
-    return this.auth.createUser(holonId, password);
-  }
-
-  /**
-   * Logout current user
-   */
-  logout() {
-    this.auth.logout();
-  }
-
-  /**
-   * Check if authenticated
-   */
-  isAuthenticated() {
-    return this.auth.isAuthenticated();
-  }
-
-  /**
-   * Write to private storage
-   */
-  async writePrivate(lens, key, data) {
-    return this.auth.writePrivate(lens, key, data);
-  }
-
-  /**
-   * Read from private storage
-   */
-  async readPrivate(lens, key) {
-    return this.auth.readPrivate(lens, key);
-  }
-
-  /**
-   * Read all from private lens
-   */
-  async readAllPrivate(lens, timeout = 2000) {
-    return this.auth.readAllPrivate(lens, timeout);
-  }
-
-  /**
-   * Delete from private storage
-   */
-  async deletePrivate(lens, key) {
-    return this.auth.deletePrivate(lens, key);
-  }
-
-  // ============================================================================
-  // SCHEMA OPERATIONS
-  // ============================================================================
-
-  /**
-   * Set a schema for a lens
-   */
-  async setSchema(lens, schema) {
-    return this.schemaValidator.setSchema(this.gun, this.appName, lens, schema);
-  }
-
-  /**
-   * Get a schema for a lens
-   */
-  async getSchema(lens, options = {}) {
-    return this.schemaValidator.getSchema(this.gun, this.appName, lens, options);
-  }
-
-  /**
-   * Get all schemas
-   */
-  async getAllSchemas() {
-    return this.schemaValidator.getAllSchemas(this.gun, this.appName);
-  }
-
-  /**
-   * Delete a schema
-   */
-  async deleteSchema(lens) {
-    return this.schemaValidator.deleteSchema(this.gun, this.appName, lens);
-  }
-
-  /**
-   * Validate data against a schema
-   */
-  validate(schema, data) {
-    return this.schemaValidator.validate(schema, data);
-  }
-
-  /**
-   * Validate data against a lens schema
-   */
-  async validateData(lens, data) {
-    return this.schemaValidator.validateData(this.gun, this.appName, lens, data);
-  }
-
-  /**
-   * Clear schema cache
-   */
-  clearSchemaCache(lens = null) {
-    this.schemaValidator.clearCache(lens);
-  }
-
-  // ============================================================================
-  // SUBSCRIPTIONS
-  // ============================================================================
-
-  async subscribe(path, callback, options = {}) {
-    const subscriptionId = ++this.subscriptionCounter;
-    const pathParts = path.split('/');
-    const isPrefix = pathParts.length <= 3;
-
-    const subscription = {
-      id: subscriptionId,
-      path,
-      active: true,
-      gunRef: null
-    };
-
-    if (isPrefix) {
-      const ref = this.gun.get(path);
-      subscription.gunRef = ref;
-
-      ref.map().on(async (data, key) => {
-        if (!this.subscriptions.get(subscriptionId)?.active) return;
-        if (!data || key.startsWith('_') || data._deleted) return;
-
-        // Parse data
-        let parsed = wrapper.parse(data);
-        if (!parsed) return;
-
-        // Resolve references if requested
-        if (options.resolveReferences && this.isReference(parsed)) {
-          parsed = await this.resolveReference(parsed);
-        }
-
-        if (parsed) {
-          callback(parsed, key);
-        }
-      });
-    } else {
-      const ref = this.gun.get(path);
-      subscription.gunRef = ref;
-
-      ref.on(async (data, key) => {
-        if (!this.subscriptions.get(subscriptionId)?.active) return;
-        if (!data) return;
-
-        let parsed = wrapper.parse(data);
-        if (!parsed || parsed._deleted) return;
-
-        if (options.resolveReferences && this.isReference(parsed)) {
-          parsed = await this.resolveReference(parsed);
-        }
-
-        if (parsed) {
-          callback(parsed, key);
-        }
-      });
-    }
-
-    this.subscriptions.set(subscriptionId, subscription);
-
-    return {
-      id: subscriptionId,
-      unsubscribe: () => {
-        const sub = this.subscriptions.get(subscriptionId);
-        if (sub) {
-          sub.active = false;
-          if (sub.gunRef) {
-            try {
-              sub.gunRef.off();
-            } catch (e) {}
-          }
-          this.subscriptions.delete(subscriptionId);
-        }
-      }
-    };
-  }
-
-  // ============================================================================
-  // EXPORT/IMPORT
-  // ============================================================================
-
-  async exportData(pathPrefix = '') {
-    const records = [];
-    const basePath = pathPrefix || this.appName;
-
-    try {
-      const items = await gunMap(this.gun.get(basePath), 2000);
-
-      for (const [key, data] of Object.entries(items)) {
-        if (!key.startsWith('_') && data && typeof data === 'object' && !data._deleted) {
-          await this._collectRecords(basePath, key, data, records);
-        }
-      }
-    } catch (error) {
-      console.warn('Export data error:', error);
-    }
-
-    return records;
-  }
-
-  async _collectRecords(basePath, key, data, records) {
-    const currentPath = `${basePath}/${key}`;
-
-    if (data.id) {
-      records.push({
-        path: currentPath,
-        data: this._cleanGunData(data),
-        timestamp: data._meta?.timestamp || Date.now(),
-      });
-    } else {
-      try {
-        const nested = await gunMap(this.gun.get(currentPath), 500);
-        for (const [nestedKey, nestedData] of Object.entries(nested)) {
-          if (!nestedKey.startsWith('_') && nestedData) {
-            await this._collectRecords(currentPath, nestedKey, nestedData, records);
-          }
-        }
-      } catch (e) {}
-    }
-  }
-
-  _cleanGunData(data) {
-    const cleaned = { ...data };
-    delete cleaned['_'];
-    return cleaned;
-  }
-
-  async importData(records, options = {}) {
-    const results = { success: 0, failed: 0, errors: [] };
-
-    for (const record of records) {
-      try {
-        await wrapper.write(this.gun, record.path, record.data);
-        results.success++;
-      } catch (error) {
-        results.failed++;
-        results.errors.push({ path: record.path, error: error.message });
-      }
-    }
-
-    return results;
-  }
-
-  // ============================================================================
-  // LIFECYCLE
-  // ============================================================================
-
-  close() {
-    // 1. Unsubscribe all active subscriptions
-    for (const [id, subscription] of this.subscriptions) {
-      if (subscription.active) {
-        subscription.active = false;
-        if (subscription.gunRef) {
-          try {
-            subscription.gunRef.off();
-          } catch (e) {}
-        }
-      }
-    }
-    this.subscriptions.clear();
-
-    // 2. Clear schema cache
-    if (this.schemaValidator) {
-      this.schemaValidator.clearCache();
-    }
-
-    // 3. Clear write cache
-    this.writeCache.clear();
-
-    // 4. Logout auth
-    if (this.auth) {
-      this.auth.logout();
-    }
-
-    // 5. Clean up Gun connections
-    if (this.gun) {
-      try {
-        // Clean up mesh connections
-        const mesh = this.gun.back('opt.mesh');
-        if (mesh) {
-          if (mesh.way) {
-            Object.values(mesh.way).forEach(conn => {
-              if (conn?.wire?.close) conn.wire.close();
-            });
-          }
-          if (mesh.opt?.peers) mesh.opt.peers = {};
-        }
-
-        // Close web server if present
-        const server = this.gun.back('opt.web');
-        if (server?.close) server.close();
-
-        // Turn off all listeners
-        this.gun.off();
-      } catch (error) {
-        console.warn('Error during Gun cleanup:', error);
-      }
-    }
-  }
-
-  getStatus() {
-    return {
-      type: 'gundb',
-      publicKey: this.publicKey,
-      peers: this.config.peers || [],
-      connected: !!this.gun,
-      authenticated: this.isAuthenticated(),
-      subscriptionCount: this.subscriptions.size,
-      schemaValidationEnabled: this.schemaValidator?.isStrict() || false
-    };
-  }
-}
-
-export default GunDBBackend;