holosphere 2.0.0-alpha1 → 2.0.0-alpha11

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

@@ -1,198 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import HoloSphere from '../../../src/index.js';
-
-describe('Contract: Cryptographic Operations', () => {
-  let hs;
-  let privateKey;
-  let publicKey;
-
-  beforeEach(async () => {
-    hs = new HoloSphere({ relays: [], appName: 'test-crypto' });
-    // Generate valid secp256k1 keys
-    privateKey = '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef';
-    publicKey = await hs.getPublicKey(privateKey);
-  });
-
-  describe('sign()', () => {
-    it('should sign object content and return hex signature', async () => {
-      const content = { message: 'Hello, HoloSphere!' };
-      const signature = await hs.sign(content, privateKey);
-
-      expect(typeof signature).toBe('string');
-      expect(signature).toMatch(/^[0-9a-f]+$/);
-    });
-
-    it('should sign string content', async () => {
-      const content = 'Hello, HoloSphere!';
-      const signature = await hs.sign(content, privateKey);
-
-      expect(typeof signature).toBe('string');
-      expect(signature).toMatch(/^[0-9a-f]+$/);
-    });
-
-    it('should throw Error for invalid private key', async () => {
-      await expect(
-        hs.sign({ message: 'Test' }, 'invalid-key')
-      ).rejects.toThrow(Error);
-    });
-
-    it('should lazy load crypto module on first call', async () => {
-      // First call should trigger lazy load
-      const signature = await hs.sign({ message: 'Test' }, privateKey);
-      expect(typeof signature).toBe('string');
-    });
-  });
-
-  describe('verify()', () => {
-    it('should return true for valid signature', async () => {
-      const content = { message: 'Hello, HoloSphere!' };
-      const signature = await hs.sign(content, privateKey);
-
-      const isValid = await hs.verify(content, signature, publicKey);
-      expect(isValid).toBe(true);
-    });
-
-    it('should return false for tampered content', async () => {
-      const content = { message: 'Hello, HoloSphere!' };
-      const signature = await hs.sign(content, privateKey);
-
-      const tamperedContent = { message: 'Tampered message' };
-      const isValid = await hs.verify(tamperedContent, signature, publicKey);
-      expect(isValid).toBe(false);
-    });
-
-    it('should return false for invalid signature', async () => {
-      const content = { message: 'Hello, HoloSphere!' };
-      const invalidSignature = 'invalid';
-
-      const isValid = await hs.verify(content, invalidSignature, publicKey);
-      expect(isValid).toBe(false);
-    });
-
-    it('should return false for wrong public key', async () => {
-      const content = { message: 'Hello, HoloSphere!' };
-      const signature = await hs.sign(content, privateKey);
-
-      const wrongPublicKey = '04' + 'fedcba9876543210'.repeat(8);
-      const isValid = await hs.verify(content, signature, wrongPublicKey);
-      expect(isValid).toBe(false);
-    });
-  });
-
-  describe('issueCapability()', () => {
-    it('should issue capability token with permissions', async () => {
-      const token = await hs.issueCapability(
-        ['read', 'write'],
-        { holonId: '8928342e20fffff', lensName: 'temperature' },
-        publicKey
-      );
-
-      expect(typeof token).toBe('string');
-      expect(token.length).toBeGreaterThan(0);
-    });
-
-    it('should accept expiresIn option', async () => {
-      const token = await hs.issueCapability(
-        ['read'],
-        { holonId: '8928342e20fffff', lensName: 'temperature' },
-        publicKey,
-        { expiresIn: 86400000 } // 24 hours
-      );
-
-      expect(typeof token).toBe('string');
-    });
-
-    it('should accept issuerKey option', async () => {
-      const token = await hs.issueCapability(
-        ['delete'],
-        { holonId: '8928342e20fffff', lensName: 'temperature' },
-        publicKey,
-        { issuerKey: privateKey }
-      );
-
-      expect(typeof token).toBe('string');
-    });
-
-    it('should throw Error for invalid issuer key', async () => {
-      await expect(
-        hs.issueCapability(
-          ['read'],
-          { holonId: '8928342e20fffff', lensName: 'temperature' },
-          publicKey,
-          { issuerKey: 'invalid-key' }
-        )
-      ).rejects.toThrow(Error);
-    });
-
-    it('should support multiple permissions', async () => {
-      const token = await hs.issueCapability(
-        ['read', 'write', 'delete'],
-        { holonId: '8928342e20fffff', lensName: 'temperature' },
-        publicKey
-      );
-
-      expect(typeof token).toBe('string');
-    });
-  });
-
-  describe('verifyCapability()', () => {
-    it('should return true for valid token with required permission', async () => {
-      const token = await hs.issueCapability(
-        ['read', 'write', 'delete'],
-        { holonId: '8928342e20fffff', lensName: 'temperature' },
-        publicKey
-      );
-
-      const isValid = await hs.verifyCapability(
-        token,
-        'delete',
-        { holonId: '8928342e20fffff', lensName: 'temperature' }
-      );
-
-      expect(isValid).toBe(true);
-    });
-
-    it('should return false for token without required permission', async () => {
-      const token = await hs.issueCapability(
-        ['read', 'write'],
-        { holonId: '8928342e20fffff', lensName: 'temperature' },
-        publicKey
-      );
-
-      const isValid = await hs.verifyCapability(
-        token,
-        'delete',
-        { holonId: '8928342e20fffff', lensName: 'temperature' }
-      );
-
-      expect(isValid).toBe(false);
-    });
-
-    it('should return false for expired token', async () => {
-      const token = await hs.issueCapability(
-        ['read'],
-        { holonId: '8928342e20fffff', lensName: 'temperature' },
-        publicKey,
-        { expiresIn: -1000 } // Already expired
-      );
-
-      const isValid = await hs.verifyCapability(
-        token,
-        'read',
-        { holonId: '8928342e20fffff', lensName: 'temperature' }
-      );
-
-      expect(isValid).toBe(false);
-    });
-
-    it('should return false for invalid token format', async () => {
-      const isValid = await hs.verifyCapability(
-        'invalid-token',
-        'read',
-        { holonId: '8928342e20fffff', lensName: 'temperature' }
-      );
-
-      expect(isValid).toBe(false);
-    });
-  });
-});

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

@@ -1,223 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import HoloSphere from '../../../src/index.js';
-
-describe('Contract: Data Operations (CRUD)', () => {
-  let hs;
-  let testHolonId;
-
-  beforeEach(async () => {
-    hs = new HoloSphere({ relays: [], appName: 'test-data' });
-    testHolonId = await hs.toHolon(37.7749, -122.4194, 9);
-  });
-
-  describe('write()', () => {
-    it('should write data with explicit ID', async () => {
-      const success = await hs.write(testHolonId, 'temperature', {
-        id: 'sensor-001',
-        value: 72.5,
-        unit: 'F'
-      });
-      expect(success).toBe(true);
-    });
-
-    it('should write data without ID (auto-generated)', async () => {
-      const success = await hs.write(testHolonId, 'temperature', {
-        value: 73.0,
-        unit: 'F'
-      });
-      expect(success).toBe(true);
-    });
-
-    it('should accept options parameter', async () => {
-      const success = await hs.write(
-        testHolonId,
-        'temperature',
-        { id: 'sensor-002', value: 74.0 },
-        { validate: false, strict: false }
-      );
-      expect(success).toBe(true);
-    });
-
-    it('should throw ValidationError in strict mode with invalid data', async () => {
-      const schema = {
-        type: 'object',
-        properties: {
-          id: { type: 'string' },
-          value: { type: 'number' }
-        },
-        required: ['id', 'value']
-      };
-      await hs.setSchema('temperature', schema, true);
-      await expect(
-        hs.write(
-          testHolonId,
-          'temperature',
-          { id: 'bad', value: 'invalid' },
-          { strict: true }
-        )
-      ).rejects.toThrow('ValidationError');
-    });
-
-    it('should throw AuthorizationError with invalid capability token', async () => {
-      await expect(
-        hs.write(
-          testHolonId,
-          'temperature',
-          { id: 'sensor-003', value: 75.0 },
-          { capability: 'invalid-token' }
-        )
-      ).rejects.toThrow('AuthorizationError');
-    });
-
-    it('should throw ValidationError with invalid holonId', async () => {
-      // Test with invalid holonId to trigger validation error
-      await expect(
-        hs.write('', 'temperature', { id: 'x' })
-      ).rejects.toThrow('ValidationError');
-    });
-  });
-
-  describe('read()', () => {
-    it('should read specific data item by ID', async () => {
-      await hs.write(testHolonId, 'temperature', {
-        id: 'sensor-001',
-        value: 72.5
-      });
-
-      const data = await hs.read(testHolonId, 'temperature', 'sensor-001');
-      expect(data).toMatchObject({ id: 'sensor-001', value: 72.5 });
-    });
-
-    it('should read all items in lens when dataId omitted', async () => {
-      await hs.write(testHolonId, 'temperature', { id: 'sensor-001', value: 72.5 });
-      await hs.write(testHolonId, 'temperature', { id: 'sensor-002', value: 73.0 });
-
-      const data = await hs.read(testHolonId, 'temperature');
-      expect(Array.isArray(data)).toBe(true);
-      expect(data.length).toBeGreaterThanOrEqual(2);
-    });
-
-    it('should return null for non-existent data', async () => {
-      const data = await hs.read(testHolonId, 'temperature', 'nonexistent');
-      expect(data).toBe(null);
-    });
-
-    it('should throw Error for invalid holonId', async () => {
-      await expect(hs.read('', 'temperature')).rejects.toThrow(Error);
-    });
-
-    it('should throw Error for invalid lensName', async () => {
-      await expect(hs.read(testHolonId, '')).rejects.toThrow(Error);
-    });
-  });
-
-  describe('update()', () => {
-    it('should update existing data by merging updates', async () => {
-      await hs.write(testHolonId, 'temperature', {
-        id: 'sensor-001',
-        value: 72.5,
-        unit: 'F'
-      });
-
-      const success = await hs.update(
-        testHolonId,
-        'temperature',
-        'sensor-001',
-        { value: 73.0 }
-      );
-      expect(success).toBe(true);
-
-      const updated = await hs.read(testHolonId, 'temperature', 'sensor-001');
-      expect(updated.value).toBe(73.0);
-      expect(updated.unit).toBe('F'); // Original field preserved
-    });
-
-    it('should return false for non-existent item', async () => {
-      const success = await hs.update(
-        testHolonId,
-        'temperature',
-        'nonexistent',
-        { value: 99 }
-      );
-      expect(success).toBe(false);
-    });
-
-    it('should accept options parameter', async () => {
-      await hs.write(testHolonId, 'temperature', { id: 'sensor-001', value: 72 });
-
-      const success = await hs.update(
-        testHolonId,
-        'temperature',
-        'sensor-001',
-        { value: 73 },
-        { validate: true, strict: false }
-      );
-      expect(success).toBe(true);
-    });
-
-    it('should throw ValidationError in strict mode', async () => {
-      const schema = {
-        type: 'object',
-        properties: {
-          id: { type: 'string' },
-          value: { type: 'number' }
-        },
-        required: ['id', 'value']
-      };
-      await hs.setSchema('temperature', schema, true);
-      await hs.write(testHolonId, 'temperature', { id: 'sensor-001', value: 72 });
-
-      await expect(
-        hs.update(
-          testHolonId,
-          'temperature',
-          'sensor-001',
-          { value: 'invalid' },
-          { strict: true }
-        )
-      ).rejects.toThrow('ValidationError');
-    });
-  });
-
-  describe('delete()', () => {
-    it('should delete own data without capability token', async () => {
-      await hs.write(testHolonId, 'temperature', { id: 'sensor-001', value: 72 });
-
-      const success = await hs.delete(testHolonId, 'temperature', 'sensor-001');
-      expect(success).toBe(true);
-
-      const deleted = await hs.read(testHolonId, 'temperature', 'sensor-001');
-      expect(deleted).toBe(null);
-    });
-
-    it('should return false when deleting non-existent data', async () => {
-      // Deleting non-existent data returns false
-      const success = await hs.delete(testHolonId, 'temperature', 'others-data');
-      expect(success).toBe(false);
-    });
-
-    it('should delete with valid capability token', async () => {
-      // First create the data to delete
-      await hs.write(testHolonId, 'temperature', { id: 'sensor-001', value: 72 });
-
-      const token = await hs.issueCapability(
-        ['delete'],
-        { holonId: testHolonId, lensName: 'temperature' },
-        hs.client.publicKey
-      );
-
-      const success = await hs.delete(
-        testHolonId,
-        'temperature',
-        'sensor-001',
-        { capability: token }
-      );
-      expect(success).toBe(true);
-    });
-
-    it('should return false on delete failure', async () => {
-      const success = await hs.delete(testHolonId, 'temperature', 'nonexistent');
-      expect(success).toBe(false);
-    });
-  });
-});

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

@@ -1,181 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import HoloSphere from '../../../src/index.js';
-
-describe('Contract: Federation Operations', () => {
-  let hs;
-  let sourceHolon;
-  let targetHolon;
-
-  beforeEach(async () => {
-    hs = new HoloSphere({ relays: [], appName: 'test-federation' });
-    sourceHolon = await hs.toHolon(37.7749, -122.4194, 9);
-    targetHolon = await hs.toHolon(37.7749, -122.4194, 7);
-  });
-
-  describe('federate()', () => {
-    it('should establish federation between two holons', async () => {
-      const success = await hs.federate(sourceHolon, targetHolon, 'events');
-      expect(success).toBe(true);
-    });
-
-    it('should accept direction option: outbound', async () => {
-      const success = await hs.federate(
-        sourceHolon,
-        targetHolon,
-        'events',
-        { direction: 'outbound' }
-      );
-      expect(success).toBe(true);
-    });
-
-    it('should accept direction option: inbound', async () => {
-      const success = await hs.federate(
-        sourceHolon,
-        targetHolon,
-        'events',
-        { direction: 'inbound' }
-      );
-      expect(success).toBe(true);
-    });
-
-    it('should accept direction option: bidirectional', async () => {
-      const success = await hs.federate(
-        sourceHolon,
-        targetHolon,
-        'events',
-        { direction: 'bidirectional' }
-      );
-      expect(success).toBe(true);
-    });
-
-    it('should accept mode option: reference (default)', async () => {
-      const success = await hs.federate(
-        sourceHolon,
-        targetHolon,
-        'events',
-        { mode: 'reference' }
-      );
-      expect(success).toBe(true);
-    });
-
-    it('should accept mode option: copy', async () => {
-      const success = await hs.federate(
-        sourceHolon,
-        targetHolon,
-        'events',
-        { mode: 'copy' }
-      );
-      expect(success).toBe(true);
-    });
-
-    it('should accept filter function option', async () => {
-      const success = await hs.federate(
-        sourceHolon,
-        targetHolon,
-        'events',
-        { filter: (data) => data.priority === 'high' }
-      );
-      expect(success).toBe(true);
-    });
-
-    it('should throw Error when source equals target', async () => {
-      await expect(
-        hs.federate(sourceHolon, sourceHolon, 'events')
-      ).rejects.toThrow(Error);
-    });
-
-    it('should succeed even with non-standard holonId', async () => {
-      // Federation setup writes config data, which succeeds even for non-H3 IDs
-      const success = await hs.federate('invalid', targetHolon, 'events');
-      expect(success).toBe(true);
-    });
-
-    it('should support cross-dimensional federation (geographic to noospheric)', async () => {
-      const noospheric = 'nostr://topic/climate';
-      const success = await hs.federate(sourceHolon, noospheric, 'temperature');
-      expect(success).toBe(true);
-    });
-  });
-
-  describe('getFederatedData()', () => {
-    it('should return combined local and federated data', async () => {
-      await hs.write(sourceHolon, 'events', { id: 'local-1', name: 'Local Event' });
-      await hs.federate(sourceHolon, targetHolon, 'events');
-
-      const data = await hs.getFederatedData(targetHolon, 'events');
-      expect(Array.isArray(data)).toBe(true);
-      expect(data.length).toBeGreaterThanOrEqual(1);
-    });
-
-    it('should accept resolveHolograms option (default: true)', async () => {
-      await hs.federate(sourceHolon, targetHolon, 'events');
-
-      const data = await hs.getFederatedData(
-        targetHolon,
-        'events',
-        { resolveHolograms: true }
-      );
-      expect(Array.isArray(data)).toBe(true);
-    });
-
-    it('should accept deduplicate option (default: true)', async () => {
-      await hs.federate(sourceHolon, targetHolon, 'events');
-
-      const data = await hs.getFederatedData(
-        targetHolon,
-        'events',
-        { deduplicate: true }
-      );
-      expect(Array.isArray(data)).toBe(true);
-    });
-
-    it('should return empty array if no data exists', async () => {
-      const data = await hs.getFederatedData(targetHolon, 'nonexistent');
-      expect(data).toEqual([]);
-    });
-
-    it('should include _meta field with source holon for federated data', async () => {
-      await hs.write(sourceHolon, 'events', { id: 'event-1', name: 'Test' });
-      await hs.federate(sourceHolon, targetHolon, 'events');
-
-      const data = await hs.getFederatedData(targetHolon, 'events');
-      const federatedItem = data.find(item => item._meta);
-
-      if (federatedItem) {
-        expect(federatedItem._meta).toHaveProperty('source');
-      }
-    });
-
-    it('should return local-only data for non-federated holon', async () => {
-      await hs.write(sourceHolon, 'events', { id: 'local-1', name: 'Local' });
-
-      const data = await hs.getFederatedData(sourceHolon, 'events');
-      expect(Array.isArray(data)).toBe(true);
-    });
-  });
-
-  describe('unfederate()', () => {
-    it('should remove federation relationship', async () => {
-      await hs.federate(sourceHolon, targetHolon, 'events');
-
-      const success = await hs.unfederate(sourceHolon, targetHolon, 'events');
-      expect(success).toBe(true);
-    });
-
-    it('should be idempotent (no error if not federated)', async () => {
-      const success = await hs.unfederate(sourceHolon, targetHolon, 'events');
-      expect(success).toBe(true);
-    });
-
-    it('should keep existing holograms after unfederate', async () => {
-      await hs.write(sourceHolon, 'events', { id: 'event-1', name: 'Test' });
-      await hs.federate(sourceHolon, targetHolon, 'events');
-      await hs.unfederate(sourceHolon, targetHolon, 'events');
-
-      // Unfederate removes federation config but doesn't delete already-propagated holograms
-      const data = await hs.getFederatedData(targetHolon, 'events');
-      const hasFederatedData = data.some(item => item._meta?.source === sourceHolon);
-      expect(hasFederatedData).toBe(true); // Holograms remain
-    });
-  });
-});