holosphere 1.1.20 → 2.0.0-alpha1

package/tests/unit/subscriptions.test.js

@@ -0,0 +1,328 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import HoloSphere from '../../src/index.js';
+
+describe('Unit: Subscriptions Module', () => {
+  let hs;
+  let testHolonId;
+
+  beforeEach(async () => {
+    hs = new HoloSphere({ relays: [], appName: 'test-subscriptions-unit' });
+    testHolonId = await hs.toHolon(37.7749, -122.4194, 9);
+  });
+
+  describe('Gun .on() listener attachment', () => {
+    it('should attach Gun listener on subscribe', () => {
+      const callback = vi.fn();
+      const subscription = hs.subscribe(testHolonId, 'test', callback);
+
+      expect(subscription).toHaveProperty('unsubscribe');
+      expect(typeof subscription.unsubscribe).toBe('function');
+
+      subscription.unsubscribe();
+    });
+
+    it('should attach listener for specific holon and lens', () => {
+      const callback = vi.fn();
+      const subscription = hs.subscribe(testHolonId, 'specific-lens', callback);
+
+      expect(subscription).toBeDefined();
+      subscription.unsubscribe();
+    });
+
+    it('should support multiple subscriptions to same holon/lens', () => {
+      const callback1 = vi.fn();
+      const callback2 = vi.fn();
+
+      const sub1 = hs.subscribe(testHolonId, 'test', callback1);
+      const sub2 = hs.subscribe(testHolonId, 'test', callback2);
+
+      expect(sub1).toBeDefined();
+      expect(sub2).toBeDefined();
+
+      sub1.unsubscribe();
+      sub2.unsubscribe();
+    });
+
+    it('should support subscriptions to different lenses', () => {
+      const callback1 = vi.fn();
+      const callback2 = vi.fn();
+
+      const sub1 = hs.subscribe(testHolonId, 'lens1', callback1);
+      const sub2 = hs.subscribe(testHolonId, 'lens2', callback2);
+
+      expect(sub1).toBeDefined();
+      expect(sub2).toBeDefined();
+
+      sub1.unsubscribe();
+      sub2.unsubscribe();
+    });
+  });
+
+  describe('Callback invocation on data changes', () => {
+    it('should invoke callback on write', async () => {
+      const callback = vi.fn();
+      const subscription = hs.subscribe(testHolonId, 'test', callback);
+
+      await hs.write(testHolonId, 'test', { id: 'item-1', value: 'data' });
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      expect(callback).toHaveBeenCalled();
+      subscription.unsubscribe();
+    });
+
+    it('should invoke callback on update', async () => {
+      await hs.write(testHolonId, 'test', { id: 'item-1', value: 'original' });
+
+      const callback = vi.fn();
+      const subscription = hs.subscribe(testHolonId, 'test', callback);
+
+      await hs.update(testHolonId, 'test', 'item-1', { value: 'updated' });
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      expect(callback).toHaveBeenCalled();
+      subscription.unsubscribe();
+    });
+
+    it('should pass data to callback', async () => {
+      const callback = vi.fn();
+      const subscription = hs.subscribe(testHolonId, 'test', callback);
+
+      await hs.write(testHolonId, 'test', { id: 'item-1', value: 'test-data' });
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      expect(callback).toHaveBeenCalledWith(
+        expect.objectContaining({ id: 'item-1', value: 'test-data' }),
+        expect.any(String)
+      );
+
+      subscription.unsubscribe();
+    });
+
+    it('should pass key to callback', async () => {
+      const callback = vi.fn();
+      const subscription = hs.subscribe(testHolonId, 'test', callback);
+
+      await hs.write(testHolonId, 'test', { id: 'item-1', value: 'data' });
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      expect(callback).toHaveBeenCalledWith(
+        expect.any(Object),
+        expect.any(String)
+      );
+
+      subscription.unsubscribe();
+    });
+
+    it('should not invoke callback on other lens changes', async () => {
+      const callback = vi.fn();
+      const subscription = hs.subscribe(testHolonId, 'lens-a', callback);
+
+      await hs.write(testHolonId, 'lens-b', { id: 'item-1', value: 'data' });
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      expect(callback).not.toHaveBeenCalled();
+      subscription.unsubscribe();
+    });
+  });
+
+  describe('Throttling mechanism', () => {
+    it('should throttle callbacks when throttle option provided', async () => {
+      const callback = vi.fn();
+      const subscription = hs.subscribe(testHolonId, 'test', callback, {
+        throttle: 500 // 500ms throttle
+      });
+
+      // Rapid writes
+      await hs.write(testHolonId, 'test', { id: 'item-1', value: 'v1' });
+      await hs.write(testHolonId, 'test', { id: 'item-2', value: 'v2' });
+      await hs.write(testHolonId, 'test', { id: 'item-3', value: 'v3' });
+
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      // Should be throttled (fewer calls than writes)
+      const callCount = callback.mock.calls.length;
+      expect(callCount).toBeLessThan(3);
+
+      subscription.unsubscribe();
+    });
+
+    it('should not throttle when throttle is 0', async () => {
+      const callback = vi.fn();
+      const subscription = hs.subscribe(testHolonId, 'test', callback, {
+        throttle: 0
+      });
+
+      await hs.write(testHolonId, 'test', { id: 'item-1', value: 'v1' });
+      await hs.write(testHolonId, 'test', { id: 'item-2', value: 'v2' });
+
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      expect(callback.mock.calls.length).toBeGreaterThanOrEqual(2);
+      subscription.unsubscribe();
+    });
+
+    it('should respect throttle interval', async () => {
+      const callback = vi.fn();
+      const subscription = hs.subscribe(testHolonId, 'test', callback, {
+        throttle: 200
+      });
+
+      await hs.write(testHolonId, 'test', { id: 'item-1', value: 'v1' });
+      await new Promise(resolve => setTimeout(resolve, 50));
+      await hs.write(testHolonId, 'test', { id: 'item-2', value: 'v2' });
+      await new Promise(resolve => setTimeout(resolve, 250));
+
+      // After throttle period, should allow next callback
+      expect(callback.mock.calls.length).toBeGreaterThan(0);
+      subscription.unsubscribe();
+    });
+  });
+
+  describe('Filter predicate application', () => {
+    it('should apply filter function', async () => {
+      const callback = vi.fn();
+      const subscription = hs.subscribe(testHolonId, 'test', callback, {
+        filter: (data) => data.value > 10
+      });
+
+      await hs.write(testHolonId, 'test', { id: 'item-1', value: 5 });
+      await hs.write(testHolonId, 'test', { id: 'item-2', value: 15 });
+
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      // Only item-2 should pass filter
+      const calls = callback.mock.calls;
+      const passedFilter = calls.some(call => call[0].value === 15);
+      const failedFilter = calls.some(call => call[0].value === 5);
+
+      expect(passedFilter).toBe(true);
+      expect(failedFilter).toBe(false);
+
+      subscription.unsubscribe();
+    });
+
+    it('should invoke callback only for data matching filter', async () => {
+      const callback = vi.fn();
+      const subscription = hs.subscribe(testHolonId, 'test', callback, {
+        filter: (data) => data.priority === 'high'
+      });
+
+      await hs.write(testHolonId, 'test', { id: 'item-1', priority: 'low' });
+      await hs.write(testHolonId, 'test', { id: 'item-2', priority: 'high' });
+      await hs.write(testHolonId, 'test', { id: 'item-3', priority: 'medium' });
+
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      const highPriorityCalls = callback.mock.calls.filter(
+        call => call[0].priority === 'high'
+      );
+
+      expect(highPriorityCalls.length).toBeGreaterThan(0);
+      subscription.unsubscribe();
+    });
+
+    it('should pass all data when no filter provided', async () => {
+      const callback = vi.fn();
+      const subscription = hs.subscribe(testHolonId, 'test', callback);
+
+      await hs.write(testHolonId, 'test', { id: 'item-1', value: 'a' });
+      await hs.write(testHolonId, 'test', { id: 'item-2', value: 'b' });
+
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      expect(callback.mock.calls.length).toBeGreaterThanOrEqual(2);
+      subscription.unsubscribe();
+    });
+  });
+
+  describe('Unsubscribe cleanup', () => {
+    it('should stop callbacks after unsubscribe', async () => {
+      const callback = vi.fn();
+      const subscription = hs.subscribe(testHolonId, 'test', callback);
+
+      subscription.unsubscribe();
+
+      await hs.write(testHolonId, 'test', { id: 'item-1', value: 'data' });
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      expect(callback).not.toHaveBeenCalled();
+    });
+
+    it('should remove Gun listener on unsubscribe', async () => {
+      const callback = vi.fn();
+      const subscription = hs.subscribe(testHolonId, 'test', callback);
+
+      await hs.write(testHolonId, 'test', { id: 'before', value: 'before' });
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      const beforeCount = callback.mock.calls.length;
+
+      subscription.unsubscribe();
+
+      await hs.write(testHolonId, 'test', { id: 'after', value: 'after' });
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      expect(callback.mock.calls.length).toBe(beforeCount);
+    });
+
+    it('should handle multiple unsubscribe calls gracefully', () => {
+      const callback = vi.fn();
+      const subscription = hs.subscribe(testHolonId, 'test', callback);
+
+      subscription.unsubscribe();
+      subscription.unsubscribe();
+      subscription.unsubscribe();
+
+      // Should not throw error
+    });
+
+    it('should cleanup individual subscriptions independently', async () => {
+      const callback1 = vi.fn();
+      const callback2 = vi.fn();
+
+      const sub1 = hs.subscribe(testHolonId, 'test', callback1);
+      const sub2 = hs.subscribe(testHolonId, 'test', callback2);
+
+      sub1.unsubscribe();
+
+      // Small delay to ensure unsubscribe is fully processed
+      await new Promise(resolve => setTimeout(resolve, 10));
+
+      await hs.write(testHolonId, 'test', { id: 'item-1', value: 'data' });
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      expect(callback1).not.toHaveBeenCalled();
+      expect(callback2).toHaveBeenCalled();
+
+      sub2.unsubscribe();
+    });
+  });
+
+  describe('Subscription options', () => {
+    it('should accept includeFederated option', () => {
+      const callback = vi.fn();
+      const subscription = hs.subscribe(testHolonId, 'test', callback, {
+        includeFederated: true
+      });
+
+      expect(subscription).toBeDefined();
+      subscription.unsubscribe();
+    });
+
+    it('should combine throttle and filter options', async () => {
+      const callback = vi.fn();
+      const subscription = hs.subscribe(testHolonId, 'test', callback, {
+        throttle: 100,
+        filter: (data) => data.value > 5
+      });
+
+      await hs.write(testHolonId, 'test', { id: 'item-1', value: 3 });
+      await hs.write(testHolonId, 'test', { id: 'item-2', value: 10 });
+
+      await new Promise(resolve => setTimeout(resolve, 200));
+
+      expect(callback.mock.calls.length).toBeGreaterThan(0);
+      subscription.unsubscribe();
+    });
+  });
+});

package/tests/unit/test-data-permanence-debug.js

@@ -0,0 +1,197 @@
+/**
+ * Debug Data Permanence Test
+ * Helps identify where in the stack data flow is breaking
+ */
+
+import { HoloSphere } from './dist/esm/holosphere.js';
+
+// Relay configuration - use env vars or these defaults
+const RELAYS = process.env.HOLOSPHERE_RELAYS?.split(',') || [
+  'wss://relay.holons.io',
+  'wss://relay.nostr.band',
+];
+
+console.log('\n=== DATA PERMANENCE DEBUG TEST ===\n');
+
+const config = {
+  appName: 'debug-test',
+  relays: RELAYS,
+  logLevel: 'DEBUG' // More verbose logging
+};
+
+console.log('Configuration:', JSON.stringify(config, null, 2));
+
+const hs = new HoloSphere(config);
+
+console.log(`\nInitialized HoloSphere`);
+console.log(`Public Key: ${hs.client.publicKey}`);
+console.log(`Private Key (first 8 chars): ${hs.client.privateKey.substring(0, 8)}...`);
+console.log(`Relays: ${config.relays.join(', ')}`);
+
+// Wait for initialization
+await new Promise(resolve => setTimeout(resolve, 2000));
+
+console.log('\n--- TEST 1: Write and immediate read ---');
+
+const testData = {
+  id: 'test-123',
+  message: 'Hello, world!',
+  timestamp: Date.now()
+};
+
+const holonId = 'global://test';
+const lensName = 'data';
+
+console.log(`\nWriting data:`);
+console.log(`  Holon: ${holonId}`);
+console.log(`  Lens: ${lensName}`);
+console.log(`  Data:`, JSON.stringify(testData, null, 2));
+
+try {
+  const writeResult = await hs.write(holonId, lensName, testData);
+  console.log(`\nWrite result: ${writeResult}`);
+
+  if (!writeResult) {
+    console.log('\n❌ Write failed - checking client state...');
+    console.log(`Client has ${hs.client._eventCache.size} cached events`);
+  }
+} catch (error) {
+  console.error('\n❌ Write error:', error);
+}
+
+console.log('\n--- Checking client cache ---');
+console.log(`Cache size: ${hs.client._eventCache.size}`);
+
+// Print cache contents
+let cacheIndex = 0;
+for (const [key, value] of hs.client._eventCache.entries()) {
+  console.log(`\nCache entry ${++cacheIndex}:`);
+  console.log(`  Key: ${key}`);
+  console.log(`  Value:`, JSON.stringify(value, null, 2));
+}
+
+console.log('\n--- Checking persistent storage ---');
+if (hs.client.persistentStorage) {
+  try {
+    const allEvents = await hs.client.persistentStorage.getAll('');
+    console.log(`Persistent storage has ${allEvents.length} events`);
+
+    for (let i = 0; i < allEvents.length; i++) {
+      const event = allEvents[i];
+      console.log(`\nEvent ${i + 1}:`);
+      console.log(`  ID: ${event.id}`);
+      console.log(`  Kind: ${event.kind}`);
+      console.log(`  Created: ${new Date(event.created_at * 1000).toISOString()}`);
+      const dTag = event.tags.find(t => t[0] === 'd');
+      if (dTag) console.log(`  D-tag: ${dTag[1]}`);
+      console.log(`  Content preview: ${event.content.substring(0, 100)}...`);
+    }
+  } catch (error) {
+    console.log('Error reading persistent storage:', error);
+  }
+} else {
+  console.log('No persistent storage initialized');
+}
+
+console.log('\n--- TEST 2: Read data back ---');
+
+try {
+  console.log(`\nReading from:`);
+  console.log(`  Holon: ${holonId}`);
+  console.log(`  Lens: ${lensName}`);
+
+  const readData = await hs.read(holonId, lensName);
+
+  console.log(`\nRead result:`, JSON.stringify(readData, null, 2));
+
+  if (!readData || readData.length === 0) {
+    console.log('\n❌ No data returned');
+
+    // Try to understand why
+    console.log('\n--- Debugging read operation ---');
+
+    // Build the path manually
+    const path = `${config.appName}/${encodeURIComponent(holonId)}/${encodeURIComponent(lensName)}`;
+    console.log(`Expected path: ${path}`);
+
+    // Check what the filter would be
+    console.log(`\nFilter that would be used:`);
+    console.log(`  kinds: [30000]`);
+    console.log(`  limit: 100`);
+
+    // Check if we can find matching events in cache
+    console.log(`\nSearching cache for matching events...`);
+    let foundInCache = false;
+    for (const [key, value] of hs.client._eventCache.entries()) {
+      if (value.events) {
+        for (const event of value.events) {
+          const dTag = event.tags.find(t => t[0] === 'd');
+          if (dTag && dTag[1].startsWith(path)) {
+            console.log(`\n✓ Found matching event in cache!`);
+            console.log(`  D-tag: ${dTag[1]}`);
+            console.log(`  Content: ${event.content}`);
+            foundInCache = true;
+          }
+        }
+      }
+    }
+
+    if (!foundInCache) {
+      console.log('No matching events found in cache');
+    }
+  } else {
+    console.log(`\n✅ Found ${readData.length} record(s)`);
+    const match = readData.find(d => d.id === testData.id);
+    if (match) {
+      console.log('✅ Test data found in results!');
+    } else {
+      console.log('❌ Test data NOT in results');
+    }
+  }
+} catch (error) {
+  console.error('\n❌ Read error:', error);
+}
+
+console.log('\n--- TEST 3: Direct client query ---');
+
+try {
+  const path = `${config.appName}/${encodeURIComponent(holonId)}/${encodeURIComponent(lensName)}`;
+  console.log(`\nQuerying with filter:`);
+
+  const filter = {
+    kinds: [30000],
+    limit: 100
+  };
+
+  console.log(JSON.stringify(filter, null, 2));
+
+  const events = await hs.client.query(filter, { timeout: 5000 });
+
+  console.log(`\nQuery returned ${events.length} events`);
+
+  for (let i = 0; i < events.length; i++) {
+    const event = events[i];
+    console.log(`\nEvent ${i + 1}:`);
+    console.log(`  ID: ${event.id.substring(0, 16)}...`);
+    console.log(`  Kind: ${event.kind}`);
+    console.log(`  Pubkey: ${event.pubkey.substring(0, 16)}...`);
+    const dTag = event.tags.find(t => t[0] === 'd');
+    if (dTag) console.log(`  D-tag: ${dTag[1]}`);
+    console.log(`  Content: ${event.content.substring(0, 100)}...`);
+  }
+
+  // Filter by path prefix
+  const matching = events.filter(event => {
+    const dTag = event.tags.find(t => t[0] === 'd');
+    return dTag && dTag[1] && dTag[1].startsWith(path);
+  });
+
+  console.log(`\n${matching.length} events match our path prefix`);
+
+} catch (error) {
+  console.error('\n❌ Query error:', error);
+}
+
+console.log('\n\n=== DEBUG TEST COMPLETE ===\n');
+
+setTimeout(() => process.exit(0), 1000);