holosphere 2.0.0-alpha20 → 2.0.0-alpha22

package/src/federation/capabilities.js

@@ -1,162 +0,0 @@
-/**
- * @fileoverview Federation Capabilities Module
- *
- * Handles capability token issuance, verification, and management
- * for federation operations. Extracted from federation-methods.js
- * for better modularity.
- *
- * @module federation/capabilities
- */
-
-import * as crypto from '../crypto/secp256k1.js';
-import * as registry from './registry.js';
-import { sha256 } from '@noble/hashes/sha256';
-import { bytesToHex } from '@noble/hashes/utils';
-
-/**
- * Issue a capability token for federation
- * @param {Object} client - NostrClient instance
- * @param {string} targetPubKey - Target public key to grant access to
- * @param {Object} scope - Access scope { holonId, lensName, dataId }
- * @param {string[]} permissions - Array of permissions ('read', 'write')
- * @param {Object} options - Capability options
- * @param {number} [options.expiresIn=3600000] - Expiration time in milliseconds
- * @param {boolean} [options.isSelfCapability=false] - Whether this is a self-capability
- * @returns {Promise<string>} Capability token
- */
-export async function issueCapability(client, targetPubKey, scope, permissions, options = {}) {
-  const {
-    expiresIn = 3600000,
-    isSelfCapability = false,
-  } = options;
-
-  const token = await crypto.issueCapability(
-    permissions,
-    scope,
-    targetPubKey,
-    {
-      expiresIn,
-      issuer: client.publicKey,
-      issuerKey: client.privateKey,
-      isSelfCapability,
-    }
-  );
-
-  return token;
-}
-
-/**
- * Issue capability for a specific lens
- * @param {Object} client - NostrClient instance
- * @param {string} holonId - Holon ID
- * @param {string} lensName - Lens name
- * @param {string} targetPubKey - Target public key
- * @param {Object} options - Options
- * @returns {Promise<Object>} Capability info { token, scope, permissions }
- */
-export async function issueCapabilityForLens(client, holonId, lensName, targetPubKey, options = {}) {
-  const {
-    permissions = ['read'],
-    expiresIn = 365 * 24 * 60 * 60 * 1000, // 1 year default
-  } = options;
-
-  const scope = { holonId, lensName, dataId: '*' };
-
-  const token = await issueCapability(client, targetPubKey, scope, permissions, {
-    expiresIn,
-    isSelfCapability: client.publicKey === targetPubKey,
-  });
-
-  return {
-    token,
-    scope,
-    permissions,
-    expiresAt: Date.now() + expiresIn,
-  };
-}
-
-/**
- * Issue capabilities for multiple lenses
- * @param {Object} client - NostrClient instance
- * @param {string} holonId - Holon ID
- * @param {string[]} lensNames - Array of lens names
- * @param {string} targetPubKey - Target public key
- * @param {Object} options - Options
- * @returns {Promise<Object[]>} Array of capability info objects
- */
-export async function issueCapabilitiesForLenses(client, holonId, lensNames, targetPubKey, options = {}) {
-  const capabilities = [];
-
-  for (const lensName of lensNames) {
-    try {
-      const capInfo = await issueCapabilityForLens(client, holonId, lensName, targetPubKey, options);
-      capabilities.push(capInfo);
-    } catch (err) {
-      console.warn(`[Capabilities] Failed to issue capability for ${lensName}:`, err.message);
-    }
-  }
-
-  return capabilities;
-}
-
-/**
- * Store a capability in the registry
- * @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
- * @returns {Promise<boolean>} Success indicator
- */
-export async function storeCapability(client, appname, partnerPubKey, capabilityInfo, options = {}) {
-  const { isSelf = false } = options;
-
-  if (isSelf) {
-    return registry.storeSelfCapability(client, appname, capabilityInfo);
-  } else {
-    return registry.storeInboundCapability(client, appname, partnerPubKey, capabilityInfo);
-  }
-}
-
-/**
- * Hash a capability token for storage
- * @param {string} token - Capability token to hash
- * @returns {string} SHA256 hash of token
- */
-export function hashToken(token) {
-  const encoder = new TextEncoder();
-  return bytesToHex(sha256(encoder.encode(token)));
-}
-
-/**
- * Verify a capability token
- * @param {string} token - Capability token
- * @param {string} permission - Required permission
- * @param {Object} scope - Requested scope
- * @returns {Promise<boolean>} True if valid
- */
-export async function verifyCapability(token, permission, scope) {
-  return crypto.verifyCapability(token, permission, scope);
-}
-
-/**
- * Get capability for accessing a partner's data
- * @param {Object} client - NostrClient instance
- * @param {string} appname - Application namespace
- * @param {string} partnerPubKey - Partner's public key
- * @param {Object} scope - Requested scope
- * @returns {Promise<Object|null>} Capability entry or null
- */
-export async function getCapabilityForPartner(client, appname, partnerPubKey, scope) {
-  return registry.getCapabilityForAuthor(client, appname, partnerPubKey, scope);
-}
-
-export default {
-  issueCapability,
-  issueCapabilityForLens,
-  issueCapabilitiesForLenses,
-  storeCapability,
-  hashToken,
-  verifyCapability,
-  getCapabilityForPartner,
-};

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');
-  }
-}