holosphere 2.0.0-alpha1 → 2.0.0-alpha4

package/tests/unit/contract/hierarchical.test.js

@@ -1,113 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import HoloSphere from '../../../src/index.js';
-
-describe('Contract: Hierarchical Operations', () => {
-  let hs;
-  let testHolonId;
-
-  beforeEach(async () => {
-    hs = new HoloSphere({ relays: [], appName: 'test-hierarchical' });
-    testHolonId = await hs.toHolon(37.7749, -122.4194, 9);
-  });
-
-  describe('upcast()', () => {
-    it('should propagate data to parent holons', async () => {
-      await hs.write(testHolonId, 'events', {
-        id: 'event-001',
-        name: 'Test Event'
-      });
-
-      const success = await hs.upcast(testHolonId, 'events', 'event-001');
-      expect(success).toBe(true);
-    });
-
-    it('should accept maxLevel option', async () => {
-      await hs.write(testHolonId, 'events', { id: 'event-001', name: 'Test' });
-
-      const success = await hs.upcast(
-        testHolonId,
-        'events',
-        'event-001',
-        { maxLevel: 3 }
-      );
-      expect(success).toBe(true);
-    });
-
-    it('should accept operation option: summarize', async () => {
-      await hs.write(testHolonId, 'events', { id: 'event-001', name: 'Test' });
-
-      const success = await hs.upcast(
-        testHolonId,
-        'events',
-        'event-001',
-        { operation: 'summarize' }
-      );
-      expect(success).toBe(true);
-    });
-
-    it('should accept operation option: aggregate', async () => {
-      await hs.write(testHolonId, 'events', { id: 'event-001', count: 5 });
-
-      const success = await hs.upcast(
-        testHolonId,
-        'events',
-        'event-001',
-        { operation: 'aggregate' }
-      );
-      expect(success).toBe(true);
-    });
-
-    it('should accept operation option: concatenate (default)', async () => {
-      await hs.write(testHolonId, 'events', { id: 'event-001', items: [1, 2, 3] });
-
-      const success = await hs.upcast(
-        testHolonId,
-        'events',
-        'event-001',
-        { operation: 'concatenate' }
-      );
-      expect(success).toBe(true);
-    });
-
-    it('should throw Error for noospheric holons (no hierarchy)', async () => {
-      const noospheric = 'nostr://topic/test';
-
-      await hs.write(noospheric, 'content', { id: 'post-1', text: 'Hello' });
-
-      await expect(
-        hs.upcast(noospheric, 'content', 'post-1')
-      ).rejects.toThrow(Error);
-    });
-
-    it('should respect maxLevel limit', async () => {
-      await hs.write(testHolonId, 'events', { id: 'event-001', name: 'Test' });
-
-      const success = await hs.upcast(
-        testHolonId,
-        'events',
-        'event-001',
-        { maxLevel: 1 }
-      );
-      expect(success).toBe(true);
-
-      // Verify data only propagated to immediate parent
-      const parents = await hs.getParents(testHolonId);
-      const immediateParent = parents[0];
-      const data = await hs.read(immediateParent, 'events');
-      expect(data.length).toBeGreaterThan(0);
-    });
-
-    it('should handle upcast to resolution 0 (global level)', async () => {
-      const highResHolon = await hs.toHolon(37.7749, -122.4194, 12);
-      await hs.write(highResHolon, 'events', { id: 'event-001', name: 'Test' });
-
-      const success = await hs.upcast(
-        highResHolon,
-        'events',
-        'event-001',
-        { maxLevel: Infinity }
-      );
-      expect(success).toBe(true);
-    });
-  });
-});

package/tests/unit/contract/schema.test.js

@@ -1,114 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import HoloSphere from '../../../src/index.js';
-
-describe('Contract: Schema Operations', () => {
-  let hs;
-
-  beforeEach(() => {
-    hs = new HoloSphere({ relays: [], appName: 'test-schema' });
-  });
-
-  describe('setSchema()', () => {
-    it('should set schema for a lens', async () => {
-      await expect(
-        hs.setSchema('temperature', 'https://example.com/schemas/temperature.json')
-      ).resolves.toBeUndefined();
-    });
-
-    it('should set schema with strict mode enabled', async () => {
-      await expect(
-        hs.setSchema('temperature', 'https://example.com/schemas/temperature.json', true)
-      ).resolves.toBeUndefined();
-    });
-
-    it('should set schema with strict mode disabled (default)', async () => {
-      await expect(
-        hs.setSchema('temperature', 'https://example.com/schemas/temperature.json', false)
-      ).resolves.toBeUndefined();
-    });
-
-    it('should accept URI schemas without fetching', async () => {
-      // URI schemas are stored as references without fetching
-      await expect(
-        hs.setSchema('temperature', 'https://nonexistent.invalid/schema.json')
-      ).resolves.toBeUndefined();
-    });
-
-    it('should store invalid schema objects and validate on use', async () => {
-      // Invalid schemas are caught during validation, not during setSchema
-      const invalidSchema = { notAValidSchema: true };
-      await expect(
-        hs.setSchema('temperature', invalidSchema)
-      ).rejects.toThrow('ValidationError');
-    });
-
-    it('should validate JSON Schema 2019 format', async () => {
-      const validSchema = {
-        $schema: 'https://json-schema.org/draft/2019-09/schema',
-        type: 'object',
-        properties: {
-          id: { type: 'string' },
-          value: { type: 'number' }
-        }
-      };
-
-      // Assuming schema can be passed directly or via URI
-      await expect(
-        hs.setSchema('temperature', 'test://valid-schema')
-      ).resolves.toBeUndefined();
-    });
-  });
-
-  describe('getSchema()', () => {
-    it('should return schema object if set', async () => {
-      await hs.setSchema('temperature', 'https://example.com/schemas/temperature.json');
-
-      const schema = await hs.getSchema('temperature');
-      expect(schema).not.toBe(null);
-      expect(typeof schema).toBe('object');
-    });
-
-    it('should return null if schema not set', async () => {
-      const schema = await hs.getSchema('nonexistent');
-      expect(schema).toBe(null);
-    });
-
-    it('should return URI reference schema object', async () => {
-      await hs.setSchema('temperature', 'https://example.com/schemas/temperature.json');
-
-      const schema = await hs.getSchema('temperature');
-      // URI schemas are stored as {$ref: uri}
-      expect(schema).toHaveProperty('$ref');
-      expect(schema.$ref).toBe('https://example.com/schemas/temperature.json');
-    });
-  });
-
-  describe('clearSchema()', () => {
-    it('should remove schema from lens', async () => {
-      await hs.setSchema('temperature', 'https://example.com/schemas/temperature.json');
-
-      await expect(
-        hs.clearSchema('temperature')
-      ).resolves.toBeUndefined();
-
-      const schema = await hs.getSchema('temperature');
-      expect(schema).toBe(null);
-    });
-
-    it('should be idempotent (no error if schema not set)', async () => {
-      await expect(
-        hs.clearSchema('nonexistent')
-      ).resolves.toBeUndefined();
-    });
-
-    it('should clear schema without affecting other lenses', async () => {
-      await hs.setSchema('temperature', 'https://example.com/schemas/temperature.json');
-      await hs.setSchema('humidity', 'https://example.com/schemas/humidity.json');
-
-      await hs.clearSchema('temperature');
-
-      expect(await hs.getSchema('temperature')).toBe(null);
-      expect(await hs.getSchema('humidity')).not.toBe(null);
-    });
-  });
-});

package/tests/unit/contract/social.test.js

@@ -1,217 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import HoloSphere from '../../../src/index.js';
-
-describe('Contract: Social Protocol Operations', () => {
-  let hs;
-  let testHolonId;
-
-  beforeEach(async () => {
-    hs = new HoloSphere({ relays: [], appName: 'test-social' });
-    testHolonId = await hs.toHolon(37.7749, -122.4194, 9);
-  });
-
-  describe('publishNostr()', () => {
-    it('should publish valid Nostr event', async () => {
-      const event = {
-        kind: 1,
-        content: 'Hello from HoloSphere!',
-        tags: [['t', 'holosphere']],
-        created_at: Math.floor(Date.now() / 1000)
-      };
-
-      const success = await hs.publishNostr(event, testHolonId);
-      expect(success).toBe(true);
-    });
-
-    it('should use default lens name "social" when not specified', async () => {
-      const event = {
-        kind: 1,
-        content: 'Test post',
-        tags: [],
-        created_at: Math.floor(Date.now() / 1000)
-      };
-
-      const success = await hs.publishNostr(event, testHolonId);
-      expect(success).toBe(true);
-    });
-
-    it('should accept custom lens name', async () => {
-      const event = {
-        kind: 1,
-        content: 'Test post',
-        tags: [],
-        created_at: Math.floor(Date.now() / 1000)
-      };
-
-      const success = await hs.publishNostr(event, testHolonId, 'custom-lens');
-      expect(success).toBe(true);
-    });
-
-    it('should throw ValidationError for invalid event format', async () => {
-      const invalidEvent = {
-        kind: 'invalid',
-        content: 123
-      };
-
-      await expect(
-        hs.publishNostr(invalidEvent, testHolonId)
-      ).rejects.toThrow('ValidationError');
-    });
-
-    it('should validate NIP-01 format', async () => {
-      const event = {
-        kind: 1,
-        content: 'Valid NIP-01 event',
-        tags: [['e', 'event-id'], ['p', 'pubkey']],
-        created_at: Math.floor(Date.now() / 1000)
-      };
-
-      const success = await hs.publishNostr(event, testHolonId);
-      expect(success).toBe(true);
-    });
-
-    it('should automatically sign event', async () => {
-      const event = {
-        kind: 1,
-        content: 'Auto-signed event',
-        tags: [],
-        created_at: Math.floor(Date.now() / 1000)
-      };
-
-      const success = await hs.publishNostr(event, testHolonId);
-      expect(success).toBe(true);
-
-      // Verify event was signed
-      const published = await hs.querySocial(testHolonId, { protocol: 'nostr' });
-      expect(published[0]).toHaveProperty('sig');
-      expect(published[0]).toHaveProperty('pubkey');
-    });
-  });
-
-  describe('publishActivityPub()', () => {
-    it('should publish valid ActivityPub object', async () => {
-      const object = {
-        '@context': 'https://www.w3.org/ns/activitystreams',
-        type: 'Note',
-        content: 'Hello from HoloSphere!',
-        published: new Date().toISOString()
-      };
-
-      const success = await hs.publishActivityPub(object, testHolonId);
-      expect(success).toBe(true);
-    });
-
-    it('should use default lens name "social" when not specified', async () => {
-      const object = {
-        '@context': 'https://www.w3.org/ns/activitystreams',
-        type: 'Note',
-        content: 'Test note'
-      };
-
-      const success = await hs.publishActivityPub(object, testHolonId);
-      expect(success).toBe(true);
-    });
-
-    it('should accept custom lens name', async () => {
-      const object = {
-        '@context': 'https://www.w3.org/ns/activitystreams',
-        type: 'Note',
-        content: 'Test note'
-      };
-
-      const success = await hs.publishActivityPub(object, testHolonId, 'custom-lens');
-      expect(success).toBe(true);
-    });
-
-    it('should throw ValidationError for invalid object format', async () => {
-      const invalidObject = {
-        type: 'Invalid',
-        content: 123
-      };
-
-      await expect(
-        hs.publishActivityPub(invalidObject, testHolonId)
-      ).rejects.toThrow('ValidationError');
-    });
-
-    it('should support different ActivityPub types', async () => {
-      const article = {
-        '@context': 'https://www.w3.org/ns/activitystreams',
-        type: 'Article',
-        name: 'Test Article',
-        content: 'Article content'
-      };
-
-      const success = await hs.publishActivityPub(article, testHolonId);
-      expect(success).toBe(true);
-    });
-  });
-
-  describe('querySocial()', () => {
-    it('should return array of social content', async () => {
-      const nostrEvent = {
-        kind: 1,
-        content: 'Test',
-        tags: [],
-        created_at: Math.floor(Date.now() / 1000)
-      };
-
-      await hs.publishNostr(nostrEvent, testHolonId);
-
-      const results = await hs.querySocial(testHolonId);
-      expect(Array.isArray(results)).toBe(true);
-    });
-
-    it('should filter by protocol: nostr', async () => {
-      const results = await hs.querySocial(testHolonId, { protocol: 'nostr' });
-      expect(Array.isArray(results)).toBe(true);
-    });
-
-    it('should filter by protocol: activitypub', async () => {
-      const results = await hs.querySocial(testHolonId, { protocol: 'activitypub' });
-      expect(Array.isArray(results)).toBe(true);
-    });
-
-    it('should filter by protocol: all (default)', async () => {
-      const results = await hs.querySocial(testHolonId, { protocol: 'all' });
-      expect(Array.isArray(results)).toBe(true);
-    });
-
-    it('should filter by accessLevel: public (default)', async () => {
-      const results = await hs.querySocial(testHolonId, { accessLevel: 'public' });
-      expect(Array.isArray(results)).toBe(true);
-    });
-
-    it('should filter by accessLevel: protected', async () => {
-      const results = await hs.querySocial(testHolonId, { accessLevel: 'protected' });
-      expect(Array.isArray(results)).toBe(true);
-    });
-
-    it('should accept custom lensName option', async () => {
-      const results = await hs.querySocial(testHolonId, { lensName: 'custom-lens' });
-      expect(Array.isArray(results)).toBe(true);
-    });
-
-    it('should return empty array if no content exists', async () => {
-      const emptyHolon = await hs.toHolon(40.7128, -74.0060, 9);
-      const results = await hs.querySocial(emptyHolon);
-      expect(results).toEqual([]);
-    });
-
-    it('should include cryptographic signatures in results', async () => {
-      const event = {
-        kind: 1,
-        content: 'Signed content',
-        tags: [],
-        created_at: Math.floor(Date.now() / 1000)
-      };
-
-      await hs.publishNostr(event, testHolonId);
-
-      const results = await hs.querySocial(testHolonId, { protocol: 'nostr' });
-      if (results.length > 0) {
-        expect(results[0]).toHaveProperty('sig');
-      }
-    });
-  });
-});

package/tests/unit/contract/spatial.test.js

@@ -1,110 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import HoloSphere from '../../../src/index.js';
-
-describe('Contract: Spatial Operations', () => {
-  const hs = new HoloSphere({ relays: [], appName: 'test-spatial' });
-
-  describe('toHolon()', () => {
-    it('should convert valid coordinates to H3 string', async () => {
-      const holonId = await hs.toHolon(37.7749, -122.4194, 9);
-      expect(typeof holonId).toBe('string');
-      expect(holonId).toMatch(/^8[0-9a-f]+$/);
-      expect(holonId.length).toBeGreaterThanOrEqual(15);
-    });
-
-    it('should throw RangeError for latitude out of bounds', async () => {
-      await expect(hs.toHolon(91, -122.4194, 9)).rejects.toThrow(RangeError);
-      await expect(hs.toHolon(-91, -122.4194, 9)).rejects.toThrow(RangeError);
-    });
-
-    it('should throw RangeError for longitude out of bounds', async () => {
-      await expect(hs.toHolon(37.7749, 181, 9)).rejects.toThrow(RangeError);
-      await expect(hs.toHolon(37.7749, -181, 9)).rejects.toThrow(RangeError);
-    });
-
-    it('should throw RangeError for invalid resolution', async () => {
-      await expect(hs.toHolon(37.7749, -122.4194, -1)).rejects.toThrow(RangeError);
-      await expect(hs.toHolon(37.7749, -122.4194, 16)).rejects.toThrow(RangeError);
-    });
-
-    it('should handle resolution 0 (largest hexagons)', async () => {
-      const holonId = await hs.toHolon(37.7749, -122.4194, 0);
-      expect(typeof holonId).toBe('string');
-    });
-
-    it('should handle resolution 15 (smallest hexagons)', async () => {
-      const holonId = await hs.toHolon(37.7749, -122.4194, 15);
-      expect(typeof holonId).toBe('string');
-    });
-  });
-
-  describe('getParents()', () => {
-    it('should return array of parent H3 IDs', async () => {
-      const holonId = await hs.toHolon(37.7749, -122.4194, 9);
-      const parents = await hs.getParents(holonId);
-      expect(Array.isArray(parents)).toBe(true);
-      expect(parents.length).toBeGreaterThan(0);
-      parents.forEach(parent => {
-        expect(typeof parent).toBe('string');
-        expect(parent).toMatch(/^8[0-9a-f]+$/);
-      });
-    });
-
-    it('should return parents up to maxResolution', async () => {
-      const holonId = await hs.toHolon(37.7749, -122.4194, 9);
-      const parents = await hs.getParents(holonId, 5);
-      expect(Array.isArray(parents)).toBe(true);
-      // Should stop at resolution 5
-    });
-
-    it('should throw Error for invalid H3 ID', async () => {
-      await expect(hs.getParents('invalid')).rejects.toThrow(Error);
-    });
-
-    it('should return empty array for resolution 0 holon', async () => {
-      const holonId = await hs.toHolon(37.7749, -122.4194, 0);
-      const parents = await hs.getParents(holonId);
-      expect(parents).toEqual([]);
-    });
-  });
-
-  describe('getChildren()', () => {
-    it('should return 7 children for valid H3 ID', async () => {
-      const holonId = await hs.toHolon(37.7749, -122.4194, 9);
-      const children = await hs.getChildren(holonId);
-      expect(Array.isArray(children)).toBe(true);
-      expect(children.length).toBe(7);
-      children.forEach(child => {
-        expect(typeof child).toBe('string');
-        expect(child).toMatch(/^8[0-9a-f]+$/);
-      });
-    });
-
-    it('should throw Error for invalid H3 ID', async () => {
-      await expect(hs.getChildren('invalid')).rejects.toThrow(Error);
-    });
-
-    it('should throw Error for resolution 15 (no children possible)', async () => {
-      const holonId = await hs.toHolon(37.7749, -122.4194, 15);
-      await expect(hs.getChildren(holonId)).rejects.toThrow(Error);
-    });
-  });
-
-  describe('isValidH3()', () => {
-    it('should return true for valid H3 ID', () => {
-      const result = hs.isValidH3('8928342e20fffff');
-      expect(result).toBe(true);
-    });
-
-    it('should return false for invalid string', () => {
-      const result = hs.isValidH3('invalid');
-      expect(result).toBe(false);
-    });
-
-    it('should return false for non-string input', () => {
-      expect(hs.isValidH3(123)).toBe(false);
-      expect(hs.isValidH3(null)).toBe(false);
-      expect(hs.isValidH3(undefined)).toBe(false);
-    });
-  });
-});

package/tests/unit/contract/subscriptions.test.js

@@ -1,128 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import HoloSphere from '../../../src/index.js';
-
-describe('Contract: Subscription Operations', () => {
-  let hs;
-  let testHolonId;
-
-  beforeEach(async () => {
-    hs = new HoloSphere({ relays: [], appName: 'test-subscriptions' });
-    testHolonId = await hs.toHolon(37.7749, -122.4194, 9);
-  });
-
-  describe('subscribe()', () => {
-    it('should return subscription object with unsubscribe method', () => {
-      const callback = vi.fn();
-      const subscription = hs.subscribe(testHolonId, 'temperature', callback);
-
-      expect(subscription).toHaveProperty('unsubscribe');
-      expect(typeof subscription.unsubscribe).toBe('function');
-    });
-
-    it('should invoke callback on data write', async () => {
-      const callback = vi.fn();
-      const subscription = hs.subscribe(testHolonId, 'temperature', callback);
-
-      await hs.write(testHolonId, 'temperature', {
-        id: 'sensor-001',
-        value: 72.5
-      });
-
-      // Wait for async callback
-      await new Promise(resolve => setTimeout(resolve, 100));
-
-      expect(callback).toHaveBeenCalled();
-      subscription.unsubscribe();
-    });
-
-    it('should invoke callback on data update', async () => {
-      await hs.write(testHolonId, 'temperature', { id: 'sensor-001', value: 72 });
-
-      const callback = vi.fn();
-      const subscription = hs.subscribe(testHolonId, 'temperature', callback);
-
-      await hs.update(testHolonId, 'temperature', 'sensor-001', { value: 73 });
-
-      await new Promise(resolve => setTimeout(resolve, 100));
-
-      expect(callback).toHaveBeenCalled();
-      subscription.unsubscribe();
-    });
-
-    it('should stop callbacks after unsubscribe', async () => {
-      const callback = vi.fn();
-      const subscription = hs.subscribe(testHolonId, 'temperature', callback);
-
-      subscription.unsubscribe();
-
-      await hs.write(testHolonId, 'temperature', { id: 'sensor-001', value: 72 });
-      await new Promise(resolve => setTimeout(resolve, 100));
-
-      expect(callback).not.toHaveBeenCalled();
-    });
-
-    it('should accept includeFederated option', () => {
-      const callback = vi.fn();
-      const subscription = hs.subscribe(
-        testHolonId,
-        'temperature',
-        callback,
-        { includeFederated: true }
-      );
-
-      expect(subscription).toHaveProperty('unsubscribe');
-      subscription.unsubscribe();
-    });
-
-    it('should accept throttle option', () => {
-      const callback = vi.fn();
-      const subscription = hs.subscribe(
-        testHolonId,
-        'temperature',
-        callback,
-        { throttle: 1000 }
-      );
-
-      expect(subscription).toHaveProperty('unsubscribe');
-      subscription.unsubscribe();
-    });
-
-    it('should accept filter option', () => {
-      const callback = vi.fn();
-      const subscription = hs.subscribe(
-        testHolonId,
-        'temperature',
-        callback,
-        { filter: (data) => data.value > 75 }
-      );
-
-      expect(subscription).toHaveProperty('unsubscribe');
-      subscription.unsubscribe();
-    });
-
-    it('should throw TypeError if callback is not a function', () => {
-      expect(() => {
-        hs.subscribe(testHolonId, 'temperature', 'not-a-function');
-      }).toThrow(TypeError);
-    });
-
-    it('should pass data and key to callback', async () => {
-      const callback = vi.fn();
-      const subscription = hs.subscribe(testHolonId, 'temperature', callback);
-
-      await hs.write(testHolonId, 'temperature', {
-        id: 'sensor-001',
-        value: 72.5
-      });
-
-      await new Promise(resolve => setTimeout(resolve, 100));
-
-      expect(callback).toHaveBeenCalledWith(
-        expect.objectContaining({ id: 'sensor-001', value: 72.5 }),
-        expect.any(String)
-      );
-
-      subscription.unsubscribe();
-    });
-  });
-});