holosphere 2.0.0-alpha21 → 2.0.0-alpha23

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

@@ -1,251 +0,0 @@
-/**
- * @fileoverview Nostr Storage Backend.
- *
- * Wraps existing nostr-wrapper.js and nostr-client.js as a StorageBackend
- * implementation. Provides Nostr-based distributed storage with relay support.
- *
- * @module storage/backends/nostr-backend
- */
-
-import { StorageBackend } from '../backend-interface.js';
-import { createClient } from '../nostr-client.js';
-import * as wrapper from '../nostr-wrapper.js';
-
-/**
- * Nostr storage backend implementation.
- *
- * Provides distributed storage using Nostr relays with event-based data storage.
- *
- * @class NostrBackend
- * @extends StorageBackend
- * @example
- * const backend = new NostrBackend({
- *   relays: ['wss://relay.example.com'],
- *   appName: 'myapp',
- *   persistence: true
- * });
- * await backend.init();
- */
-export class NostrBackend extends StorageBackend {
-  /**
-   * Create a new NostrBackend.
-   *
-   * @param {Object} config - Backend configuration
-   * @param {string[]} [config.relays] - Relay URLs
-   * @param {string} [config.privateKey] - Private key for signing
-   * @param {string} [config.appName] - Application name
-   * @param {boolean} [config.persistence=true] - Enable persistent storage
-   * @param {boolean} [config.backgroundSync] - Enable background sync
-   */
-  constructor(config) {
-    super(config);
-    this.client = null;
-  }
-
-  /**
-   * Initialize the backend.
-   *
-   * @returns {Promise<void>}
-   */
-  async init() {
-    this.client = createClient({
-      relays: this.config.relays || ['wss://relay.holons.io'],
-      privateKey: this.config.privateKey,
-      enableReconnect: this.config.enableReconnect !== false,
-      enablePing: this.config.enablePing !== false,
-      appName: this.config.appName,
-      radisk: this.config.radisk !== false,
-      persistence: this.config.persistence !== false,
-      dataDir: this.config.dataDir,
-      backgroundSync: this.config.backgroundSync,
-      syncInterval: this.config.syncInterval,
-    });
-
-    // Wait for client initialization
-    await this.client._initReady;
-    this.publicKey = this.client.publicKey;
-  }
-
-  /**
-   * Build path from components.
-   *
-   * @param {string} appName - Application name
-   * @param {string} holonId - Holon ID
-   * @param {string} lensName - Lens name
-   * @param {string} [key=null] - Optional key
-   * @returns {string} Built path
-   */
-  buildPath(appName, holonId, lensName, key = null) {
-    return wrapper.buildPath(appName, holonId, lensName, key);
-  }
-
-  /**
-   * Write data to path.
-   *
-   * @param {string} path - Storage path
-   * @param {Object} data - Data to write
-   * @param {Object} [options={}] - Write options
-   * @returns {Promise<Object>} Write result
-   */
-  async write(path, data, options = {}) {
-    return wrapper.write(this.client, path, data);
-  }
-
-  /**
-   * Read data from path.
-   *
-   * @param {string} path - Storage path
-   * @param {Object} [options={}] - Read options
-   * @returns {Promise<Object|null>} Data or null
-   */
-  async read(path, options = {}) {
-    return wrapper.read(this.client, path, options);
-  }
-
-  /**
-   * Read all data under path.
-   *
-   * @param {string} path - Storage path prefix
-   * @param {Object} [options={}] - Read options
-   * @returns {Promise<Object[]>} Array of data objects
-   */
-  async readAll(path, options = {}) {
-    return wrapper.readAll(this.client, path, options);
-  }
-
-  /**
-   * Update data at path.
-   *
-   * @param {string} path - Storage path
-   * @param {Object} updates - Fields to update
-   * @returns {Promise<Object>} Update result
-   */
-  async update(path, updates) {
-    return wrapper.update(this.client, path, updates);
-  }
-
-  /**
-   * Delete data at path.
-   *
-   * @param {string} path - Storage path
-   * @returns {Promise<boolean>} Success indicator
-   */
-  async delete(path) {
-    return wrapper.deleteData(this.client, path);
-  }
-
-  /**
-   * Delete all data under path.
-   *
-   * @param {string} path - Storage path prefix
-   * @returns {Promise<Object>} Deletion results
-   */
-  async deleteAll(path) {
-    return wrapper.deleteAll(this.client, path);
-  }
-
-  /**
-   * Subscribe to changes at path.
-   *
-   * @param {string} path - Storage path
-   * @param {Function} callback - Callback function
-   * @param {Object} [options={}] - Subscribe options
-   * @returns {Promise<Object>} Subscription object with unsubscribe method
-   */
-  async subscribe(path, callback, options = {}) {
-    return wrapper.subscribe(this.client, path, callback, options);
-  }
-
-  /**
-   * Export all data for this user.
-   *
-   * @param {string} [pathPrefix=''] - Optional path prefix filter
-   * @returns {Promise<Object[]>} Array of exported records
-   */
-  async exportData(pathPrefix = '') {
-    // Wait for client to be ready
-    await this.client._initReady;
-
-    // Query all events for this author
-    const events = await this.client.query({
-      kinds: [30000],
-      authors: [this.publicKey],
-      limit: 10000,
-    });
-
-    return events
-      .filter(e => {
-        const dTag = e.tags.find(t => t[0] === 'd');
-        if (!dTag) return false;
-        // Filter by prefix if provided
-        if (pathPrefix && !dTag[1].startsWith(pathPrefix)) return false;
-        return true;
-      })
-      .map(e => {
-        const dTag = e.tags.find(t => t[0] === 'd');
-        let data;
-        try {
-          data = JSON.parse(e.content);
-        } catch {
-          data = { content: e.content };
-        }
-        return {
-          path: dTag[1],
-          data,
-          timestamp: e.created_at * 1000,
-          author: e.pubkey,
-        };
-      })
-      .filter(record => !record.data._deleted); // Filter out deleted items
-  }
-
-  /**
-   * Import data records.
-   *
-   * @param {Object[]} records - Array of records to import
-   * @param {Object} [options={}] - Import options
-   * @returns {Promise<Object>} Import results with success/failed counts
-   */
-  async importData(records, options = {}) {
-    const results = { success: 0, failed: 0, errors: [] };
-
-    for (const record of records) {
-      try {
-        await wrapper.write(this.client, record.path, record.data);
-        results.success++;
-      } catch (error) {
-        results.failed++;
-        results.errors.push({ path: record.path, error: error.message });
-      }
-    }
-
-    return results;
-  }
-
-  /**
-   * Close the backend and cleanup resources.
-   *
-   * @returns {void}
-   */
-  close() {
-    if (this.client) {
-      this.client.close();
-    }
-  }
-
-  /**
-   * Get backend status.
-   *
-   * @returns {Object} Status object with type, publicKey, relays, connected
-   */
-  getStatus() {
-    return {
-      type: 'nostr',
-      publicKey: this.publicKey,
-      relays: this.config.relays || [],
-      connected: !!this.client,
-    };
-  }
-}
-
-export default NostrBackend;

package/src/storage/gun-async.js

@@ -1,341 +0,0 @@
-/**
- * @fileoverview Gun Async Utilities.
- *
- * Provides Promise-based wrappers and async patterns for Gun operations.
- * Includes utilities for promises, batch operations, retries, streams, and async iteration.
- *
- * @module storage/gun-async
- */
-
-/**
- * Get data from Gun using native .then() support.
- *
- * @param {Object} gunChain - Gun chain reference
- * @param {number} [timeout=1000] - Timeout in ms
- * @returns {Promise<any>} Promise resolving to data or null on timeout
- */
-export function gunPromise(gunChain, timeout = 1000) {
-  return new Promise((resolve, reject) => {
-    let settled = false;
-
-    const timer = setTimeout(() => {
-      if (!settled) {
-        settled = true;
-        resolve(null);
-      }
-    }, timeout);
-
-    gunChain.once((data) => {
-      if (!settled) {
-        settled = true;
-        clearTimeout(timer);
-        resolve(data || null);
-      }
-    });
-  });
-}
-
-/**
- * Wait for Gun write acknowledgement.
- *
- * @param {Object} gunChain - Gun chain reference
- * @param {any} data - Data to write
- * @param {number} [timeout=1000] - Timeout in ms
- * @returns {Promise<Object>} Promise resolving to ack object { ok, timeout? }
- * @throws {Error} If write fails with error
- */
-export function gunPut(gunChain, data, timeout = 1000) {
-  return new Promise((resolve, reject) => {
-    let settled = false;
-
-    const timer = setTimeout(() => {
-      if (!settled) {
-        settled = true;
-        resolve({ ok: true, timeout: true });
-      }
-    }, timeout);
-
-    gunChain.put(data, (ack) => {
-      if (!settled) {
-        settled = true;
-        clearTimeout(timer);
-        if (ack.err) {
-          reject(new Error(ack.err));
-        } else {
-          resolve(ack);
-        }
-      }
-    });
-  });
-}
-
-/**
- * Get all items from a Gun map.
- *
- * First gets count of items, then collects until count is reached.
- *
- * @param {Object} gunChain - Gun chain reference
- * @param {number} [timeout=5000] - Timeout in ms (fallback)
- * @returns {Promise<Object>} Promise resolving to map of items
- */
-export async function gunMap(gunChain, timeout = 5000) {
-  return new Promise((resolve) => {
-    const items = {};
-    let settled = false;
-    let expectedCount = 0;
-    let receivedCount = 0;
-
-    const tryResolve = () => {
-      if (settled) return;
-      if (expectedCount > 0 && receivedCount >= expectedCount) {
-        settled = true;
-        resolve(items);
-      }
-    };
-
-    // Step 1: Get parent to count expected items
-    gunChain.once((parentData) => {
-      if (settled) return;
-
-      if (!parentData) {
-        settled = true;
-        resolve({});
-        return;
-      }
-
-      const keys = Object.keys(parentData).filter(k => k !== '_');
-      if (keys.length === 0) {
-        settled = true;
-        resolve({});
-        return;
-      }
-
-      // Pre-collect inline items (not Gun references)
-      for (const key of keys) {
-        const rawItem = parentData[key];
-        if (!rawItem) continue;
-
-        // Skip Gun references - will be fetched via map().once()
-        if (typeof rawItem === 'object' && rawItem['#']) continue;
-
-        items[key] = rawItem;
-      }
-
-      // Expected count is ALL keys (map().once() fires for all)
-      expectedCount = keys.length;
-
-      // Step 2: Collect items via map().once(), counting as we go
-      gunChain.map().once((data, key) => {
-        if (settled || !data || key.startsWith('_')) return;
-        // Add/update the item (inline items may be updated by map().once())
-        items[key] = data;
-        receivedCount++;
-        tryResolve();
-      });
-    });
-
-    // Fallback timeout
-    setTimeout(() => {
-      if (!settled) {
-        settled = true;
-        resolve(items);
-      }
-    }, timeout);
-  });
-}
-
-/**
- * Load full chain data (follows all references)
- * @param {Object} gunChain - Gun chain reference
- * @param {number} depth - Max depth to traverse (default 3)
- * @returns {Promise<any>} Promise resolving to loaded data
- */
-export async function gunLoad(gunChain, depth = 3) {
-  return new Promise((resolve) => {
-    let result = null;
-
-    gunChain.load((data) => {
-      result = data;
-    }, { wait: 100 });
-
-    setTimeout(() => {
-      resolve(result);
-    }, 100 * depth);
-  });
-}
-
-/**
- * Async iterator for Gun map
- * @param {Object} gunChain - Gun chain reference
- * @returns {AsyncGenerator} Async generator yielding [key, value] pairs
- */
-export async function* gunMapIterator(gunChain) {
-  const items = await gunMap(gunChain);
-  for (const [key, value] of Object.entries(items)) {
-    yield [key, value];
-  }
-}
-
-/**
- * Collect Gun on() stream into array over time
- * @param {Object} gunChain - Gun chain reference
- * @param {number} duration - Collection duration in ms
- * @returns {Promise<Array>} Promise resolving to array of data
- */
-export async function gunCollect(gunChain, duration = 500) {
-  return new Promise((resolve) => {
-    const results = [];
-    const seen = new Set();
-
-    const listener = gunChain.on((data, key) => {
-      if (data && !seen.has(key)) {
-        seen.add(key);
-        results.push({ key, data });
-      }
-    });
-
-    setTimeout(() => {
-      listener.off();
-      resolve(results);
-    }, duration);
-  });
-}
-
-/**
- * Wait for specific condition on Gun data
- * @param {Object} gunChain - Gun chain reference
- * @param {Function} predicate - Condition function (data) => boolean
- * @param {number} timeout - Timeout in ms (default 5000ms)
- * @returns {Promise<any>} Promise resolving when condition is met
- */
-export async function gunWaitFor(gunChain, predicate, timeout = 5000) {
-  return new Promise((resolve, reject) => {
-    let timeoutId;
-    let listener;
-
-    const cleanup = () => {
-      if (timeoutId) clearTimeout(timeoutId);
-      if (listener) listener.off();
-    };
-
-    listener = gunChain.on((data) => {
-      if (predicate(data)) {
-        cleanup();
-        resolve(data);
-      }
-    });
-
-    timeoutId = setTimeout(() => {
-      cleanup();
-      reject(new Error('Timeout waiting for condition'));
-    }, timeout);
-  });
-}
-
-/**
- * Batch read multiple Gun paths
- * @param {Object} gun - Gun instance
- * @param {string[]} paths - Array of paths to read
- * @returns {Promise<Object>} Object mapping paths to data
- */
-export async function gunBatchGet(gun, paths) {
-  const promises = paths.map(async (path) => {
-    const data = await gunPromise(gun.get(path));
-    return [path, data];
-  });
-
-  const results = await Promise.all(promises);
-  return Object.fromEntries(results);
-}
-
-/**
- * Batch write multiple Gun paths
- * @param {Object} gun - Gun instance
- * @param {Object} pathDataMap - Object mapping paths to data
- * @returns {Promise<Object>} Object mapping paths to ack results
- */
-export async function gunBatchPut(gun, pathDataMap) {
-  const promises = Object.entries(pathDataMap).map(async ([path, data]) => {
-    const ack = await gunPut(gun.get(path), data);
-    return [path, ack];
-  });
-
-  const results = await Promise.all(promises);
-  return Object.fromEntries(results);
-}
-
-/**
- * Retry Gun operation with exponential backoff
- * @param {Function} operation - Async function to retry
- * @param {number} maxRetries - Max retry attempts (default 3)
- * @param {number} baseDelay - Base delay in ms (default 100ms)
- * @returns {Promise<any>} Promise resolving to operation result
- */
-export async function gunRetry(operation, maxRetries = 3, baseDelay = 100) {
-  let lastError;
-
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    try {
-      return await operation();
-    } catch (error) {
-      lastError = error;
-      if (attempt < maxRetries) {
-        const delay = baseDelay * Math.pow(2, attempt);
-        await new Promise((resolve) => setTimeout(resolve, delay));
-      }
-    }
-  }
-
-  throw lastError;
-}
-
-/**
- * Create async stream from Gun on() callback
- * @param {Object} gunChain - Gun chain reference
- * @returns {Object} Stream object with async iteration support
- */
-export function gunStream(gunChain) {
-  let listeners = [];
-  let buffer = [];
-  let ended = false;
-
-  const stream = {
-    [Symbol.asyncIterator]() {
-      return {
-        async next() {
-          if (buffer.length > 0) {
-            return { value: buffer.shift(), done: false };
-          }
-
-          if (ended) {
-            return { done: true };
-          }
-
-          // Wait for next value
-          return new Promise((resolve) => {
-            listeners.push((data) => {
-              resolve({ value: data, done: false });
-            });
-          });
-        },
-      };
-    },
-
-    stop() {
-      ended = true;
-      if (this.listener) this.listener.off();
-    },
-  };
-
-  stream.listener = gunChain.on((data, key) => {
-    const item = { key, data };
-    if (listeners.length > 0) {
-      const listener = listeners.shift();
-      listener(item);
-    } else {
-      buffer.push(item);
-    }
-  });
-
-  return stream;
-}