holosphere 1.1.20 → 2.0.0-alpha1

package/tests/unit/integration/scenario-04-validation.test.js

@@ -0,0 +1,129 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import HoloSphere from '../../../src/index.js';
+
+describe('Integration: Scenario 4 - Schema Validation (Strict and Permissive)', () => {
+  let hs;
+
+  beforeEach(() => {
+    hs = new HoloSphere({ relays: [], appName: 'scenario-04' });
+  });
+
+  it('should complete schema validation workflow', async () => {
+    // Step 1: Define schema for temperature data
+    const temperatureSchema = {
+      type: 'object',
+      properties: {
+        id: { type: 'string' },
+        celsius: { type: 'number', minimum: -50, maximum: 60 },
+        timestamp: { type: 'number' }
+      },
+      required: ['id', 'celsius']
+    };
+
+    const holon = await hs.toHolon(37.7749, -122.4194, 9);
+
+    // Step 2: Set schema in permissive mode (default)
+    await hs.setSchema('temperature', temperatureSchema, false);
+
+    // Step 3: Write invalid data - succeeds with warning logged
+    const permissiveResult = await hs.write(holon, 'temperature', {
+      id: 'bad-sensor',
+      celsius: 'very hot'  // Invalid: string instead of number
+    });
+    expect(permissiveResult).toBe(true);
+
+    // Step 4: Enable strict mode
+    await hs.setSchema('temperature', temperatureSchema, true);
+
+    // Step 5: Write invalid data - throws ValidationError
+    await expect(
+      hs.write(holon, 'temperature', {
+        id: 'bad-sensor-2',
+        celsius: 'freezing'
+      }, { strict: true })
+    ).rejects.toThrow('ValidationError');
+
+    // Step 6: Write valid data - succeeds
+    const validResult = await hs.write(holon, 'temperature', {
+      id: 'good-sensor',
+      celsius: 22.5,
+      timestamp: Date.now()
+    }, { strict: true });
+    expect(validResult).toBe(true);
+  });
+
+  it('should validate schemas support URI references', async () => {
+    // URI schemas can be set and will skip validation
+    await expect(
+      hs.setSchema('test', 'test://schemas/valid.json')
+    ).resolves.toBeUndefined();
+  });
+
+  it('should validate permissive mode logs but allows invalid data', async () => {
+    const holon = await hs.toHolon(37.7749, -122.4194, 9);
+    const testSchema = {
+      type: 'object',
+      properties: {
+        id: { type: 'string' },
+        value: { type: 'number' }
+      },
+      required: ['id', 'value']
+    };
+    await hs.setSchema('test', testSchema, false);
+
+    const result = await hs.write(holon, 'test', {
+      id: 'invalid',
+      value: 'not-a-number'
+    });
+
+    expect(result).toBe(true);
+  });
+
+  it('should validate strict mode blocks invalid data with ValidationError', async () => {
+    const holon = await hs.toHolon(37.7749, -122.4194, 9);
+    const strictSchema = {
+      type: 'object',
+      properties: {
+        id: { type: 'string' },
+        value: { type: 'number' }
+      },
+      required: ['id', 'value']
+    };
+    await hs.setSchema('strict-test', strictSchema, true);
+
+    await expect(
+      hs.write(holon, 'strict-test', {
+        id: 'bad',
+        value: 'invalid'
+      }, { strict: true })
+    ).rejects.toThrow('ValidationError');
+  });
+
+  it('should validate valid data succeeds in both modes', async () => {
+    const holon = await hs.toHolon(37.7749, -122.4194, 9);
+    const tempSchema = {
+      type: 'object',
+      properties: {
+        id: { type: 'string' },
+        celsius: { type: 'number' },
+        timestamp: { type: 'number' }
+      },
+      required: ['id', 'celsius']
+    };
+    const validData = {
+      id: 'sensor-001',
+      celsius: 25.5,
+      timestamp: Date.now()
+    };
+
+    // Permissive mode
+    await hs.setSchema('temp1', tempSchema, false);
+    const permissive = await hs.write(holon, 'temp1', validData);
+    expect(permissive).toBe(true);
+
+    // Strict mode
+    await hs.setSchema('temp2', tempSchema, true);
+    const strict = await hs.write(holon, 'temp2', validData, { strict: true });
+    expect(strict).toBe(true);
+  });
+});

package/tests/unit/integration/scenario-05-hierarchy.test.js

@@ -0,0 +1,125 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import HoloSphere from '../../../src/index.js';
+
+describe('Integration: Scenario 5 - Multi-Scale Hierarchical Queries', () => {
+  let hs;
+
+  beforeEach(() => {
+    hs = new HoloSphere({ relays: [], appName: 'scenario-05' });
+  });
+
+  it('should complete multi-scale hierarchical query workflow', async () => {
+    // Step 1: Create data at high resolution (local street level, res 12)
+    const localHolon = await hs.toHolon(37.7749, -122.4194, 12);
+    await hs.write(localHolon, 'events', {
+      id: 'meetup-001',
+      name: 'JavaScript Meetup',
+      attendees: 25
+    });
+
+    // Step 2: Upcast to parent hierarchy (propagate to neighborhood, city, region)
+    const upcastSuccess = await hs.upcast(localHolon, 'events', 'meetup-001', {
+      maxLevel: 3
+    });
+    expect(upcastSuccess).toBe(true);
+
+    // Step 3: Query at different scales
+    const parents = await hs.getParents(localHolon);
+    expect(parents.length).toBeGreaterThan(0);
+
+    // Find neighborhood level (estimate resolution 9)
+    const neighborhood = parents.find(p => {
+      // Get resolution somehow or just use first parent
+      return true;
+    });
+
+    if (neighborhood) {
+      const neighborhoodEvents = await hs.read(neighborhood, 'events');
+      expect(Array.isArray(neighborhoodEvents)).toBe(true);
+      // Should include upcast data
+    }
+
+    // City level (lower resolution parent)
+    if (parents.length > 1) {
+      const city = parents[1];
+      const cityEvents = await hs.read(city, 'events');
+      expect(Array.isArray(cityEvents)).toBe(true);
+    }
+
+    // Regional level
+    if (parents.length > 2) {
+      const region = parents[2];
+      const regionEvents = await hs.read(region, 'events');
+      expect(Array.isArray(regionEvents)).toBe(true);
+    }
+  });
+
+  it('should validate hierarchical parent-child relationships maintained', async () => {
+    const child = await hs.toHolon(37.7749, -122.4194, 10);
+    const parents = await hs.getParents(child);
+
+    expect(parents.length).toBeGreaterThan(0);
+
+    // Each parent should be valid H3
+    parents.forEach(parent => {
+      expect(hs.isValidH3(parent)).toBe(true);
+    });
+  });
+
+  it('should validate data propagates up hierarchy (upcast)', async () => {
+    const local = await hs.toHolon(40.7128, -74.0060, 11);
+
+    await hs.write(local, 'alerts', {
+      id: 'alert-001',
+      type: 'weather',
+      severity: 'high'
+    });
+
+    await hs.upcast(local, 'alerts', 'alert-001', { maxLevel: 2 });
+
+    const parents = await hs.getParents(local);
+    if (parents.length > 0) {
+      const parentData = await hs.read(parents[0], 'alerts');
+      expect(Array.isArray(parentData)).toBe(true);
+    }
+  });
+
+  it('should validate multi-scale queries work at different resolutions', async () => {
+    // Create data at resolution 12
+    const res12 = await hs.toHolon(37.7749, -122.4194, 12);
+    await hs.write(res12, 'data', { id: 'item-1', value: 'high-res' });
+
+    // Get data at resolution 9 (parent)
+    const parents = await hs.getParents(res12);
+    const res9 = parents.find(p => hs.isValidH3(p));
+
+    if (res9) {
+      // Should be able to query at this resolution
+      const data = await hs.read(res9, 'data');
+      expect(Array.isArray(data)).toBe(true);
+    }
+
+    // Resolution 7 (grandparent)
+    if (parents.length > 1) {
+      const res7 = parents[1];
+      const data = await hs.read(res7, 'data');
+      expect(Array.isArray(data)).toBe(true);
+    }
+  });
+
+  it('should validate upcast with different operation modes', async () => {
+    const holon = await hs.toHolon(37.7749, -122.4194, 10);
+
+    // Summarize mode
+    await hs.write(holon, 'counts', { id: 'count-1', value: 5 });
+    await hs.upcast(holon, 'counts', 'count-1', { operation: 'summarize' });
+
+    // Aggregate mode
+    await hs.write(holon, 'totals', { id: 'total-1', amount: 100 });
+    await hs.upcast(holon, 'totals', 'total-1', { operation: 'aggregate' });
+
+    // Concatenate mode (default)
+    await hs.write(holon, 'lists', { id: 'list-1', items: [1, 2, 3] });
+    await hs.upcast(holon, 'lists', 'list-1', { operation: 'concatenate' });
+  });
+});

package/tests/unit/integration/scenario-06-social.test.js

@@ -0,0 +1,135 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import HoloSphere from '../../../src/index.js';
+
+describe('Integration: Scenario 6 - Cross-Protocol Social Content', () => {
+  let hs;
+
+  beforeEach(() => {
+    hs = new HoloSphere({ relays: [], appName: 'scenario-06' });
+  });
+
+  it('should complete cross-protocol social content workflow', async () => {
+    // Step 1: Publish Nostr event to geographic holon
+    const holon = await hs.toHolon(37.7749, -122.4194, 9);
+
+    const nostrEvent = {
+      kind: 1,  // Text note
+      content: 'Building with HoloSphere!',
+      tags: [['t', 'holosphere'], ['t', 'geospatial']],
+      created_at: Math.floor(Date.now() / 1000)
+    };
+
+    const nostrSuccess = await hs.publishNostr(nostrEvent, holon);
+    expect(nostrSuccess).toBe(true);
+
+    // Step 2: Publish ActivityPub object to noospheric holon
+    const apObject = {
+      '@context': 'https://www.w3.org/ns/activitystreams',
+      type: 'Note',
+      content: 'Exploring federated social on HoloSphere',
+      published: new Date().toISOString()
+    };
+
+    const apSuccess = await hs.publishActivityPub(
+      apObject,
+      'ap://community/holosphere-devs'
+    );
+    expect(apSuccess).toBe(true);
+
+    // Step 3: Query all social content (unified interface)
+    const allSocial = await hs.querySocial(holon, { protocol: 'all' });
+    expect(Array.isArray(allSocial)).toBe(true);
+    expect(allSocial.length).toBeGreaterThanOrEqual(1);
+
+    // Step 4: Filter by protocol
+    const nostrOnly = await hs.querySocial(holon, { protocol: 'nostr' });
+    expect(Array.isArray(nostrOnly)).toBe(true);
+    expect(nostrOnly.length).toBeGreaterThanOrEqual(1);
+
+    // Step 5: Verify cryptographic signature
+    if (nostrOnly.length > 0) {
+      const event = nostrOnly[0];
+      expect(event).toHaveProperty('sig');
+      expect(event).toHaveProperty('pubkey');
+
+      // Use verifyNostrEvent for proper Nostr signature verification
+      const isValid = await hs.verifyNostrEvent(event);
+      expect(isValid).toBe(true);
+    }
+  });
+
+  it('should validate Nostr and ActivityPub unified under common interface', async () => {
+    const holon = await hs.toHolon(40.7128, -74.0060, 9);
+
+    // Publish both types
+    await hs.publishNostr({
+      kind: 1,
+      content: 'Nostr post',
+      tags: [],
+      created_at: Math.floor(Date.now() / 1000)
+    }, holon);
+
+    await hs.publishActivityPub({
+      '@context': 'https://www.w3.org/ns/activitystreams',
+      type: 'Note',
+      content: 'ActivityPub note'
+    }, holon);
+
+    // Query should return both
+    const all = await hs.querySocial(holon, { protocol: 'all' });
+    expect(all.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it('should validate protocol-specific content validation', async () => {
+    const holon = await hs.toHolon(37.7749, -122.4194, 9);
+
+    // Invalid Nostr event should be rejected
+    await expect(
+      hs.publishNostr({ invalid: 'event' }, holon)
+    ).rejects.toThrow('ValidationError');
+
+    // Invalid ActivityPub object should be rejected
+    await expect(
+      hs.publishActivityPub({ invalid: 'object' }, holon)
+    ).rejects.toThrow('ValidationError');
+  });
+
+  it('should validate cryptographic signature verification', async () => {
+    const holon = await hs.toHolon(37.7749, -122.4194, 9);
+
+    const event = {
+      kind: 1,
+      content: 'Signed content',
+      tags: [],
+      created_at: Math.floor(Date.now() / 1000)
+    };
+
+    await hs.publishNostr(event, holon);
+
+    const published = await hs.querySocial(holon, { protocol: 'nostr' });
+    if (published.length > 0) {
+      const signedEvent = published[0];
+      expect(signedEvent).toHaveProperty('sig');
+      expect(signedEvent).toHaveProperty('pubkey');
+    }
+  });
+
+  it('should validate filter by protocol and access level', async () => {
+    const holon = await hs.toHolon(37.7749, -122.4194, 9);
+
+    await hs.publishNostr({
+      kind: 1,
+      content: 'Public post',
+      tags: [],
+      created_at: Math.floor(Date.now() / 1000)
+    }, holon);
+
+    // Filter by protocol
+    const nostrPosts = await hs.querySocial(holon, { protocol: 'nostr' });
+    expect(Array.isArray(nostrPosts)).toBe(true);
+
+    // Filter by access level
+    const publicPosts = await hs.querySocial(holon, { accessLevel: 'public' });
+    expect(Array.isArray(publicPosts)).toBe(true);
+  });
+});

package/tests/unit/integration/scenario-07-persistence.test.js

@@ -0,0 +1,130 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import HoloSphere from '../../../src/index.js';
+
+describe('Integration: Scenario 7 - Offline Persistence and Recovery', () => {
+  let hs;
+
+  beforeEach(() => {
+    hs = new HoloSphere({
+      appName: 'scenario-07',
+      radisk: true  // Enabled by default
+    });
+  });
+
+  it('should complete offline persistence and recovery workflow', async () => {
+    const holon = await hs.toHolon(37.7749, -122.4194, 9);
+
+    // Step 1: Write data to persistent storage
+    await hs.write(holon, 'notes', {
+      id: 'note-001',
+      text: 'This persists across sessions'
+    });
+
+    // Verify write succeeded
+    const written = await hs.read(holon, 'notes', 'note-001');
+    expect(written.text).toBe('This persists across sessions');
+
+    // Step 2: Simulate app restart (create new instance)
+    const hs2 = new HoloSphere({
+      appName: 'scenario-07',
+      radisk: true
+    });
+
+    // Step 3: Read previously written data - recovered from disk
+    const recovered = await hs2.read(holon, 'notes', 'note-001');
+    expect(recovered).not.toBe(null);
+    expect(recovered.text).toBe('This persists across sessions');
+
+    // Step 4: Offline operation - write without network
+    await hs2.write(holon, 'notes', {
+      id: 'note-002',
+      text: 'Written while offline'
+    });
+
+    // Step 5: Data available immediately from local storage
+    const offline = await hs2.read(holon, 'notes', 'note-002');
+    expect(offline).not.toBe(null);
+    expect(offline.text).toBe('Written while offline');
+  });
+
+  it('should validate radisk persistence enabled by default', () => {
+    const hs = new HoloSphere({ relays: [], appName: 'test-radisk' });
+    // Should initialize without error with radisk enabled
+    expect(hs).toBeDefined();
+  });
+
+  it.skip('should validate data persists across app restarts (requires persistent storage)', async () => {
+    const appName = 'persistence-test-' + Date.now();
+    const holon = await hs.toHolon(40.7128, -74.0060, 9);
+
+    // First instance
+    const hs1 = new HoloSphere({ appName, radisk: true });
+    await hs1.write(holon, 'persistent', {
+      id: 'persistent-001',
+      value: 'must persist'
+    });
+
+    // Second instance (simulated restart)
+    const hs2 = new HoloSphere({ appName, radisk: true });
+    const recovered = await hs2.read(holon, 'persistent', 'persistent-001');
+
+    expect(recovered).not.toBe(null);
+    expect(recovered.value).toBe('must persist');
+  });
+
+  it('should validate offline writes succeed and are recoverable', async () => {
+    const holon = await hs.toHolon(37.7749, -122.4194, 9);
+
+    // Write while potentially offline (radisk handles this)
+    const success = await hs.write(holon, 'offline-data', {
+      id: 'offline-001',
+      timestamp: Date.now(),
+      status: 'offline-write'
+    });
+
+    expect(success).toBe(true);
+
+    // Verify immediately available
+    const data = await hs.read(holon, 'offline-data', 'offline-001');
+    expect(data).not.toBe(null);
+    expect(data.status).toBe('offline-write');
+  });
+
+  it.skip('should validate no data loss during crashes (requires persistent storage)', async () => {
+    const appName = 'crash-test-' + Date.now();
+    const holon = await hs.toHolon(37.7749, -122.4194, 9);
+
+    const hs1 = new HoloSphere({ appName, radisk: true });
+
+    // Write multiple items
+    await hs1.write(holon, 'crash-test', { id: 'item-1', data: 'A' });
+    await hs1.write(holon, 'crash-test', { id: 'item-2', data: 'B' });
+    await hs1.write(holon, 'crash-test', { id: 'item-3', data: 'C' });
+
+    // Simulate crash and restart
+    const hs2 = new HoloSphere({ appName, radisk: true });
+
+    // All data should be recoverable
+    const item1 = await hs2.read(holon, 'crash-test', 'item-1');
+    const item2 = await hs2.read(holon, 'crash-test', 'item-2');
+    const item3 = await hs2.read(holon, 'crash-test', 'item-3');
+
+    expect(item1?.data).toBe('A');
+    expect(item2?.data).toBe('B');
+    expect(item3?.data).toBe('C');
+  });
+
+  it.skip('should validate persistence works with updates (requires persistent storage)', async () => {
+    const appName = 'update-persist-' + Date.now();
+    const holon = await hs.toHolon(37.7749, -122.4194, 9);
+
+    const hs1 = new HoloSphere({ appName, radisk: true });
+    await hs1.write(holon, 'updatable', { id: 'item-1', version: 1 });
+    await hs1.update(holon, 'updatable', 'item-1', { version: 2 });
+
+    const hs2 = new HoloSphere({ appName, radisk: true });
+    const recovered = await hs2.read(holon, 'updatable', 'item-1');
+
+    expect(recovered.version).toBe(2); // Updated version persisted
+  });
+});

package/tests/unit/integration/scenario-08-authorization.test.js

@@ -0,0 +1,161 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import HoloSphere from '../../../src/index.js';
+
+describe('Integration: Scenario 8 - Authorization with Capability Tokens', () => {
+  let hs;
+  let userAPrivateKey;
+  let userAPublicKey;
+  let userBPublicKey;
+
+  beforeEach(() => {
+    hs = new HoloSphere({ relays: [], appName: 'scenario-08' });
+
+    // Mock keys (in real implementation, would use proper key generation)
+    userAPrivateKey = '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef';
+    userAPublicKey = '04' + '0123456789abcdef'.repeat(8);
+    userBPublicKey = '04' + 'fedcba9876543210'.repeat(8);
+  });
+
+  it('should complete authorization with capability tokens workflow', async () => {
+    const holon = await hs.toHolon(37.7749, -122.4194, 9);
+
+    // Step 1: User A creates data
+    await hs.write(holon, 'documents', {
+      id: 'doc-001',
+      title: 'User A Document',
+      _creator: userAPublicKey
+    });
+
+    // Step 2: User B attempts to delete without authorization
+    try {
+      await hs.delete(holon, 'documents', 'doc-001');
+      // Should throw, but if not, fail the test
+      expect(true).toBe(false);
+    } catch (err) {
+      expect(err.constructor.name).toBe('AuthorizationError');
+      expect(err.requiredPermission).toBe('delete');
+    }
+
+    // Step 3: User A issues capability token to User B
+    const token = await hs.issueCapability(
+      ['delete'],
+      { holonId: holon, lensName: 'documents' },
+      userBPublicKey,
+      { expiresIn: 3600000, issuerKey: userAPrivateKey }
+    );
+
+    expect(typeof token).toBe('string');
+
+    // Step 4: User B deletes with valid token
+    const deleted = await hs.delete(holon, 'documents', 'doc-001', {
+      capability: token
+    });
+    expect(deleted).toBe(true);
+
+    // Step 5: Verify data is deleted
+    const gone = await hs.read(holon, 'documents', 'doc-001');
+    expect(gone).toBe(null);
+  });
+
+  it('should validate delete without capability token is rejected', async () => {
+    const holon = await hs.toHolon(40.7128, -74.0060, 9);
+
+    await hs.write(holon, 'protected', {
+      id: 'protected-001',
+      owner: userAPublicKey
+    });
+
+    await expect(
+      hs.delete(holon, 'protected', 'protected-001')
+    ).rejects.toThrow('AuthorizationError');
+  });
+
+  it('should validate capability tokens grant specific permissions', async () => {
+    const holon = await hs.toHolon(37.7749, -122.4194, 9);
+
+    // Issue token with only 'read' permission
+    const readToken = await hs.issueCapability(
+      ['read'],
+      { holonId: holon, lensName: 'test' },
+      userBPublicKey,
+      { issuerKey: userAPrivateKey }
+    );
+
+    // Verify token has 'read' permission
+    const hasRead = await hs.verifyCapability(
+      readToken,
+      'read',
+      { holonId: holon, lensName: 'test' }
+    );
+    expect(hasRead).toBe(true);
+
+    // Verify token does NOT have 'delete' permission
+    const hasDelete = await hs.verifyCapability(
+      readToken,
+      'delete',
+      { holonId: holon, lensName: 'test' }
+    );
+    expect(hasDelete).toBe(false);
+  });
+
+  it('should validate token expiration is enforced', async () => {
+    const holon = await hs.toHolon(37.7749, -122.4194, 9);
+
+    // Issue expired token
+    const expiredToken = await hs.issueCapability(
+      ['delete'],
+      { holonId: holon, lensName: 'test' },
+      userBPublicKey,
+      { expiresIn: -1000, issuerKey: userAPrivateKey }
+    );
+
+    // Expired token should not be valid
+    const isValid = await hs.verifyCapability(
+      expiredToken,
+      'delete',
+      { holonId: holon, lensName: 'test' }
+    );
+    expect(isValid).toBe(false);
+  });
+
+  it('should validate data creators can delete their own data', async () => {
+    const holon = await hs.toHolon(37.7749, -122.4194, 9);
+
+    await hs.write(holon, 'my-data', {
+      id: 'my-item-001',
+      content: 'My content'
+    });
+
+    // Owner should be able to delete without capability token
+    const deleted = await hs.delete(holon, 'my-data', 'my-item-001');
+    expect(deleted).toBe(true);
+  });
+
+  it('should validate capability tokens work across different lenses', async () => {
+    const holon = await hs.toHolon(37.7749, -122.4194, 9);
+
+    // Token for lens 'documents'
+    const docToken = await hs.issueCapability(
+      ['delete'],
+      { holonId: holon, lensName: 'documents' },
+      userBPublicKey,
+      { issuerKey: userAPrivateKey }
+    );
+
+    // Should be valid for 'documents' lens
+    const validForDocs = await hs.verifyCapability(
+      docToken,
+      'delete',
+      { holonId: holon, lensName: 'documents' }
+    );
+    expect(validForDocs).toBe(true);
+
+    // Should NOT be valid for 'photos' lens
+    const validForPhotos = await hs.verifyCapability(
+      docToken,
+      'delete',
+      { holonId: holon, lensName: 'photos' }
+    );
+    expect(validForPhotos).toBe(false);
+  });
+});