holosphere 2.0.0-alpha21 → 2.0.0-alpha23

package/src/federation/capabilities.js

@@ -1,46 +0,0 @@
-/**
- * @fileoverview Federation Capabilities Module — Re-exports
- *
- * This module re-exports capability functions from their canonical locations
- * (crypto/secp256k1.js and federation/registry.js) for backward compatibility.
- *
- * Prefer importing directly from the canonical modules in new code.
- *
- * @module federation/capabilities
- */
-
-export {
-  issueCapability,
-  verifyCapability,
-  hashToken,
-} from '../crypto/secp256k1.js';
-
-export {
-  issueCapabilityForLens,
-  issueCapabilitiesForLenses,
-  getCapabilityForAuthor as getCapabilityForPartner,
-  storeInboundCapability,
-  storeSelfCapability,
-} from './registry.js';
-
-import { storeSelfCapability, storeInboundCapability } from './registry.js';
-
-/**
- * Store a capability in the registry (convenience wrapper)
- * @param {Object} client - NostrClient instance
- * @param {string} appname - Application namespace
- * @param {string} partnerPubKey - Partner's public key
- * @param {Object} capabilityInfo - Capability info to store
- * @param {Object} options - Options
- * @param {boolean} [options.isSelf=false] - Whether this is a self-capability
- * @returns {Promise<boolean>} Success indicator
- */
-export async function storeCapability(client, appname, partnerPubKey, capabilityInfo, options = {}) {
-  const { isSelf = false } = options;
-
-  if (isSelf) {
-    return storeSelfCapability(client, appname, capabilityInfo);
-  } else {
-    return storeInboundCapability(client, appname, partnerPubKey, capabilityInfo);
-  }
-}

package/src/storage/backend-factory.js

@@ -1,130 +0,0 @@
-/**
- * @fileoverview Factory for Creating Storage Backends.
- *
- * Provides a factory pattern for creating and managing storage backend instances.
- * Supports lazy loading of backend implementations to reduce initial bundle size.
- *
- * @module storage/backend-factory
- */
-
-/** @type {Object<string, string>} Map of backend types to their module paths */
-const BACKEND_MODULES = {
-  nostr: './backends/nostr-backend.js',
-  gundb: './backends/gundb-backend.js',
-  activitypub: './backends/activitypub-backend.js',
-};
-
-// Cache for loaded backend classes
-const loadedBackends = new Map();
-
-/**
- * Factory for creating storage backends
- */
-export class BackendFactory {
-  /**
-   * Get list of available backend types
-   * @returns {string[]} Available backend type names
-   */
-  static getAvailableBackends() {
-    return Object.keys(BACKEND_MODULES);
-  }
-
-  /**
-   * Check if a backend type is available
-   * @param {string} type - Backend type
-   * @returns {boolean} Whether the backend is available
-   */
-  static isAvailable(type) {
-    return type in BACKEND_MODULES;
-  }
-
-  /**
-   * Load a backend class dynamically
-   * @param {string} type - Backend type
-   * @returns {Promise<Class>} Backend class
-   */
-  static async loadBackend(type) {
-    if (loadedBackends.has(type)) {
-      return loadedBackends.get(type);
-    }
-
-    const modulePath = BACKEND_MODULES[type];
-    if (!modulePath) {
-      throw new Error(
-        `Unknown backend type: '${type}'. Available backends: ${Object.keys(BACKEND_MODULES).join(', ')}`
-      );
-    }
-
-    try {
-      const module = await import(modulePath);
-      const BackendClass = module.default || module[`${capitalize(type)}Backend`];
-
-      if (!BackendClass) {
-        throw new Error(`Backend module '${type}' does not export a valid backend class`);
-      }
-
-      loadedBackends.set(type, BackendClass);
-      return BackendClass;
-    } catch (error) {
-      if (error.code === 'ERR_MODULE_NOT_FOUND') {
-        throw new Error(
-          `Backend '${type}' requires additional dependencies. ` +
-          `Please install them: ${getDependencyHint(type)}`
-        );
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Create a storage backend instance
-   * @param {string} type - Backend type: 'nostr' | 'gundb' | 'activitypub'
-   * @param {Object} config - Backend-specific configuration
-   * @returns {Promise<StorageBackend>} Initialized backend
-   */
-  static async create(type, config) {
-    const BackendClass = await this.loadBackend(type);
-    const backend = new BackendClass(config);
-    await backend.init();
-    return backend;
-  }
-
-  /**
-   * Register a custom backend
-   * @param {string} name - Backend name
-   * @param {Class|string} BackendClassOrPath - Backend class or module path
-   */
-  static register(name, BackendClassOrPath) {
-    if (typeof BackendClassOrPath === 'string') {
-      BACKEND_MODULES[name] = BackendClassOrPath;
-    } else {
-      loadedBackends.set(name, BackendClassOrPath);
-      BACKEND_MODULES[name] = null; // Mark as registered but not file-based
-    }
-  }
-}
-
-/**
- * Capitalize first letter
- * @param {string} str - String to capitalize
- * @returns {string} Capitalized string
- */
-function capitalize(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-}
-
-/**
- * Get dependency installation hint for a backend
- * @param {string} type - Backend type
- * @returns {string} Installation hint
- */
-function getDependencyHint(type) {
-  const hints = {
-    nostr: 'npm install nostr-tools',
-    gundb: 'npm install gun',
-    activitypub: 'npm install express',
-  };
-  return hints[type] || 'Check the documentation for required dependencies';
-}
-
-export default BackendFactory;

package/src/storage/backend-interface.js

@@ -1,161 +0,0 @@
-/**
- * @fileoverview Abstract Storage Backend Interface.
- *
- * Defines the contract that all storage backends must implement.
- * Provides a consistent API for CRUD operations, subscriptions,
- * and data migration across different storage technologies.
- *
- * @module storage/backend-interface
- */
-
-/**
- * Abstract base class for storage backends.
- * All concrete backends (Nostr, GunDB, ActivityPub) must extend this class.
- *
- * @abstract
- * @class StorageBackend
- */
-export class StorageBackend {
-  /**
-   * Creates a new StorageBackend instance.
-   *
-   * @param {Object} config - Backend-specific configuration
-   * @throws {Error} If instantiated directly (abstract class)
-   */
-  constructor(config) {
-    if (new.target === StorageBackend) {
-      throw new Error('StorageBackend is abstract and cannot be instantiated directly');
-    }
-    this.config = config;
-    this.publicKey = null;
-  }
-
-  /**
-   * Initialize the backend
-   * @returns {Promise<void>}
-   */
-  async init() {
-    throw new Error('init() must be implemented by subclass');
-  }
-
-  /**
-   * Build path from components
-   * @param {string} appName - Application namespace
-   * @param {string} holonId - Holon identifier (H3 hex or URI)
-   * @param {string} lensName - Lens name
-   * @param {string} [key] - Optional data key
-   * @returns {string} Constructed path
-   */
-  buildPath(appName, holonId, lensName, key = null) {
-    throw new Error('buildPath() must be implemented by subclass');
-  }
-
-  /**
-   * Write data to storage
-   * @param {string} path - Storage path
-   * @param {Object} data - Data to write
-   * @param {Object} [options] - Write options
-   * @returns {Promise<boolean>} Success indicator
-   */
-  async write(path, data, options = {}) {
-    throw new Error('write() must be implemented by subclass');
-  }
-
-  /**
-   * Read data from storage
-   * @param {string} path - Storage path
-   * @param {Object} [options] - Read options
-   * @param {string[]} [options.authors] - Public keys to query
-   * @param {boolean} [options.includeAuthor] - Include author in response
-   * @returns {Promise<Object|null>} Data or null
-   */
-  async read(path, options = {}) {
-    throw new Error('read() must be implemented by subclass');
-  }
-
-  /**
-   * Read all data under a path prefix
-   * @param {string} path - Path prefix
-   * @param {Object} [options] - Query options
-   * @param {boolean} [options.hybrid] - Use hybrid mode (local + remote)
-   * @param {string[]} [options.authors] - Public keys to query
-   * @returns {Promise<Object[]>} Array of data objects
-   */
-  async readAll(path, options = {}) {
-    throw new Error('readAll() must be implemented by subclass');
-  }
-
-  /**
-   * Update data (merge fields)
-   * @param {string} path - Storage path
-   * @param {Object} updates - Fields to update
-   * @returns {Promise<boolean>} Success indicator
-   */
-  async update(path, updates) {
-    throw new Error('update() must be implemented by subclass');
-  }
-
-  /**
-   * Delete data at path
-   * @param {string} path - Storage path
-   * @returns {Promise<boolean>} Success indicator
-   */
-  async delete(path) {
-    throw new Error('delete() must be implemented by subclass');
-  }
-
-  /**
-   * Delete all data under path prefix
-   * @param {string} path - Path prefix
-   * @returns {Promise<Object>} Deletion results { success: boolean, count: number }
-   */
-  async deleteAll(path) {
-    throw new Error('deleteAll() must be implemented by subclass');
-  }
-
-  /**
-   * Subscribe to data changes
-   * @param {string} path - Path or path prefix
-   * @param {Function} callback - Called on changes: (data, key) => void
-   * @param {Object} [options] - Subscription options
-   * @returns {Promise<Object>} Subscription with unsubscribe() method
-   */
-  async subscribe(path, callback, options = {}) {
-    throw new Error('subscribe() must be implemented by subclass');
-  }
-
-  /**
-   * Export all data for migration
-   * @param {string} [pathPrefix] - Optional prefix to filter
-   * @returns {Promise<Object[]>} Array of exportable records
-   */
-  async exportData(pathPrefix = '') {
-    throw new Error('exportData() must be implemented by subclass');
-  }
-
-  /**
-   * Import data from migration
-   * @param {Object[]} records - Records to import
-   * @param {Object} [options] - Import options
-   * @param {boolean} [options.overwrite] - Overwrite existing data
-   * @returns {Promise<Object>} Import results { success: number, failed: number, errors: [] }
-   */
-  async importData(records, options = {}) {
-    throw new Error('importData() must be implemented by subclass');
-  }
-
-  /**
-   * Close connections and cleanup
-   */
-  close() {
-    throw new Error('close() must be implemented by subclass');
-  }
-
-  /**
-   * Get backend status/health
-   * @returns {Object} Status information { type, publicKey, connected, ... }
-   */
-  getStatus() {
-    throw new Error('getStatus() must be implemented by subclass');
-  }
-}