holosphere 2.0.0-alpha21 → 2.0.0-alpha23

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

@@ -1,295 +0,0 @@
-/**
- * @fileoverview ActivityPub storage backend client adapter.
- * Provides HTTP-based connectivity to an ActivityPub server for federated data storage
- * and real-time subscriptions via Server-Sent Events.
- * @module storage/backends/activitypub-backend
- */
-
-import { StorageBackend } from '../backend-interface.js';
-
-/**
- * ActivityPub storage backend implementation.
- * Client adapter for connecting to an ActivityPub server via HTTP API
- * with SSE-based real-time subscriptions.
- *
- * @class ActivityPubBackend
- * @extends StorageBackend
- * @example
- * const backend = await BackendFactory.create('activitypub', {
- *   serverUrl: 'https://ap.example.com',
- *   appName: 'myapp',
- *   apiKey: 'secret-key'
- * });
- */
-export class ActivityPubBackend extends StorageBackend {
-  /**
-   * Create a new ActivityPub backend instance.
-   * @param {Object} config - Backend configuration
-   * @param {string} config.serverUrl - ActivityPub server URL
-   * @param {string} [config.appName='holosphere'] - Application/actor name
-   * @param {string} [config.apiKey] - Optional API key for authentication
-   */
-  constructor(config) {
-    super(config);
-    this.serverUrl = config.serverUrl;
-    this.actorName = config.appName || 'holosphere';
-    this.apiKey = config.apiKey;
-    this.actorId = null;
-  }
-
-  async init() {
-    if (!this.serverUrl) {
-      throw new Error('ActivityPub backend requires serverUrl in config');
-    }
-
-    // Ensure server URL doesn't have trailing slash
-    this.serverUrl = this.serverUrl.replace(/\/$/, '');
-
-    // Try to fetch or create actor
-    try {
-      const response = await fetch(`${this.serverUrl}/actor/${this.actorName}`, {
-        headers: { 'Accept': 'application/activity+json' },
-      });
-
-      if (response.ok) {
-        const actor = await response.json();
-        this.actorId = actor.id;
-        this.publicKey = actor.publicKey?.id || actor.id;
-      } else {
-        // Try to create actor
-        await this._createActor();
-      }
-    } catch (error) {
-      // Server might not be running yet, try to create actor
-      await this._createActor();
-    }
-  }
-
-  async _createActor() {
-    try {
-      const response = await this._fetch(`${this.serverUrl}/api/actors`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          name: this.actorName,
-          apiKey: this.apiKey,
-        }),
-      });
-
-      if (response.ok) {
-        const result = await response.json();
-        this.actorId = result.id;
-        this.publicKey = result.publicKey || result.id;
-      } else {
-        throw new Error(`Failed to create actor: ${response.status}`);
-      }
-    } catch (error) {
-      // If server is not available, set placeholder values
-      this.actorId = `${this.serverUrl}/actor/${this.actorName}`;
-      this.publicKey = this.actorId;
-    }
-  }
-
-  buildPath(appName, holonId, lensName, key = null) {
-    // Use same path format as other backends
-    const encodedHolon = encodeURIComponent(holonId);
-    const encodedLens = encodeURIComponent(lensName);
-
-    if (key) {
-      const encodedKey = encodeURIComponent(key);
-      return `${appName}/${encodedHolon}/${encodedLens}/${encodedKey}`;
-    }
-    return `${appName}/${encodedHolon}/${encodedLens}`;
-  }
-
-  async write(path, data, options = {}) {
-    const response = await this._fetch(`${this.serverUrl}/api/data`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        path,
-        data,
-        actorName: this.actorName,
-      }),
-    });
-
-    return response.ok;
-  }
-
-  async read(path, options = {}) {
-    const response = await this._fetch(`${this.serverUrl}/api/data/${path}`);
-
-    if (!response.ok) {
-      if (response.status === 404) return null;
-      throw new Error(`Read failed: ${response.status}`);
-    }
-
-    const data = await response.json();
-    return data._deleted ? null : data;
-  }
-
-  async readAll(path, options = {}) {
-    const response = await this._fetch(`${this.serverUrl}/api/data/${path}`);
-
-    if (!response.ok) {
-      if (response.status === 404) return [];
-      throw new Error(`ReadAll failed: ${response.status}`);
-    }
-
-    const data = await response.json();
-    return Array.isArray(data) ? data.filter(item => !item._deleted) : [data];
-  }
-
-  async update(path, updates) {
-    // Read existing, merge, write back
-    const existing = await this.read(path);
-    if (!existing) return false;
-
-    const merged = { ...existing, ...updates };
-    return this.write(path, merged);
-  }
-
-  async delete(path) {
-    const response = await this._fetch(
-      `${this.serverUrl}/api/data/${path}?actor=${this.actorName}`,
-      { method: 'DELETE' }
-    );
-
-    return response.ok;
-  }
-
-  async deleteAll(path) {
-    const items = await this.readAll(path);
-    let count = 0;
-
-    for (const item of items) {
-      if (item && item.id) {
-        await this.delete(`${path}/${item.id}`);
-        count++;
-      }
-    }
-
-    return { success: true, count };
-  }
-
-  async subscribe(path, callback, options = {}) {
-    // Use Server-Sent Events for real-time updates
-    const url = `${this.serverUrl}/subscribe?path=${encodeURIComponent(path)}`;
-
-    // Use EventSource if available (browser) or polyfill
-    let eventSource;
-
-    if (typeof EventSource !== 'undefined') {
-      eventSource = new EventSource(url);
-    } else {
-      // In Node.js, we need to use a different approach
-      // For now, return a polling-based subscription
-      return this._pollSubscribe(path, callback, options);
-    }
-
-    eventSource.addEventListener('update', (event) => {
-      try {
-        const { path: eventPath, data } = JSON.parse(event.data);
-        const key = eventPath.split('/').pop();
-        callback(data, key);
-      } catch (error) {
-        console.error('ActivityPub subscription error:', error);
-      }
-    });
-
-    eventSource.onerror = (error) => {
-      console.error('ActivityPub SSE error:', error);
-    };
-
-    return {
-      unsubscribe: () => eventSource.close(),
-    };
-  }
-
-  async _pollSubscribe(path, callback, options = {}) {
-    // Fallback polling for Node.js environments
-    const interval = options.pollInterval || 5000;
-    let lastTimestamp = Date.now();
-    let running = true;
-
-    const poll = async () => {
-      while (running) {
-        try {
-          const items = await this.readAll(path);
-          for (const item of items) {
-            if (item._meta?.timestamp > lastTimestamp) {
-              const key = item.id || item._meta?.path?.split('/').pop();
-              callback(item, key);
-              lastTimestamp = item._meta.timestamp;
-            }
-          }
-        } catch (error) {
-          console.error('Polling error:', error);
-        }
-
-        await new Promise(resolve => setTimeout(resolve, interval));
-      }
-    };
-
-    // Start polling
-    poll();
-
-    return {
-      unsubscribe: () => { running = false; },
-    };
-  }
-
-  async exportData(pathPrefix = '') {
-    const items = await this.readAll(pathPrefix || this.actorName);
-
-    return items.map(item => ({
-      path: item._meta?.path || `${pathPrefix}/${item.id}`,
-      data: item,
-      timestamp: item._meta?.timestamp || Date.now(),
-    }));
-  }
-
-  async importData(records, options = {}) {
-    const results = { success: 0, failed: 0, errors: [] };
-
-    for (const record of records) {
-      try {
-        await this.write(record.path, record.data);
-        results.success++;
-      } catch (error) {
-        results.failed++;
-        results.errors.push({ path: record.path, error: error.message });
-      }
-    }
-
-    return results;
-  }
-
-  async _fetch(url, options = {}) {
-    const headers = options.headers || {};
-
-    // Add authorization if we have an API key
-    if (this.apiKey) {
-      headers['Authorization'] = `Bearer ${this.apiKey}`;
-    }
-
-    return fetch(url, { ...options, headers });
-  }
-
-  close() {
-    // Nothing to close for HTTP client
-  }
-
-  getStatus() {
-    return {
-      type: 'activitypub',
-      serverUrl: this.serverUrl,
-      actorId: this.actorId,
-      actorName: this.actorName,
-      publicKey: this.publicKey,
-      connected: true,
-    };
-  }
-}
-
-export default ActivityPubBackend;