holosphere 2.0.0-alpha1 → 2.0.0-alpha10

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

@@ -1,129 +0,0 @@
-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

@@ -1,125 +0,0 @@
-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

@@ -1,135 +0,0 @@
-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

@@ -1,130 +0,0 @@
-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

@@ -1,161 +0,0 @@
-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);
-  });
-});