holosphere 1.1.8 → 1.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "holosphere",
-  "version": "1.1.8",
+  "version": "1.1.10",
   "description": "Holonic Geospatial Communication Infrastructure",
   "main": "holosphere.js",
   "types": "holosphere.d.ts",

package/test/auth.test.js

@@ -1,10 +1,8 @@
-import Gun from 'gun';
 import HoloSphere from '../holosphere.js';
-import * as h3 from 'h3-js';
 import { jest } from '@jest/globals';
 
 // Increase timeout for all tests
-jest.setTimeout(3000);
+jest.setTimeout(30000);
 
 describe('HoloSphere Authentication and Authorization', () => {
     let holoSphere;
@@ -16,6 +14,14 @@ describe('HoloSphere Authentication and Authorization', () => {
     beforeAll(async () => {
         holoSphere = new HoloSphere('test-app', false, null);
         strictHoloSphere = new HoloSphere('test-app-strict', true, null);
+        // Wait for initialization
+        await new Promise(resolve => setTimeout(resolve, 1000));
+    });
+
+    beforeEach(async () => {
+        // Clean state before each test
+        await holoSphere.deleteAll(testHolon, testLens);
+        await new Promise(resolve => setTimeout(resolve, 100));
     });
 
     afterEach(async () => {
@@ -37,12 +43,12 @@ describe('HoloSphere Authentication and Authorization', () => {
         await holoSphere.deleteAll(testHolon, testLens);
         await holoSphere.deleteAllGlobal('testTable');
         
-        // Close Gun connections
-        if (holoSphere.gun) {
-            holoSphere.gun.off();
+        // Close HoloSphere instances
+        if (holoSphere) {
+            await holoSphere.close();
         }
-        if (strictHoloSphere.gun) {
-            strictHoloSphere.gun.off();
+        if (strictHoloSphere) {
+            await strictHoloSphere.close();
         }
         
         // Wait for connections to close
@@ -50,16 +56,25 @@ describe('HoloSphere Authentication and Authorization', () => {
     });
 
     describe('Authentication System', () => {
-        it('should authenticate with password and store/retrieve data', async () => {
+        it('should authenticate with password and handle auth failures', async () => {
             const testData = { id: 'test1', value: 'private-data' };
             
             // Test storing with authentication
             await holoSphere.put(testHolon, testLens, testData, testPassword);
+            // Wait for data to be properly stored
+            await new Promise(resolve => setTimeout(resolve, 100));
             
-            // Test retrieving with authentication
-            const result = await holoSphere.get(testHolon, testLens, testData.id, testPassword);
-            expect(result).toBeDefined();
-            expect(result.value).toBe(testData.value);
+            // Test retrieving with wrong password
+            const wrongResult = await holoSphere.get(testHolon, testLens, testData.id, 'wrong_password');
+            expect(wrongResult).toBeNull();
+            
+            // Test retrieving with no password
+            const noPassResult = await holoSphere.get(testHolon, testLens, testData.id);
+            expect(noPassResult).toBeNull();
+            
+            // Test retrieving with correct password
+            const correctResult = await holoSphere.get(testHolon, testLens, testData.id, testPassword);
+            expect(correctResult).toEqual(testData);  // Use full object comparison
         });
 
         it('should handle authentication errors gracefully', async () => {
@@ -103,15 +118,16 @@ describe('HoloSphere Authentication and Authorization', () => {
             const testData = { id: 'test', value: 123 };
             
             // Should work in non-strict mode without schema
-            await expect(holoSphere.put(testHolon, testLens, testData)).resolves.toBeTruthy();
+            await expect(holoSphere.put(testHolon, 'nonExistentLens', testData)).resolves.toBeTruthy();
             
-            // Delete any existing schema
-            await strictHoloSphere.putGlobal('schemas', { id: testLens, schema: null });
+            // Delete any existing schema for the lens
+            await strictHoloSphere.putGlobal('schemas', { id: 'nonExistentLens', schema: null });
             
-            // Should fail in strict mode without schema
             try {
-                await strictHoloSphere.put(testHolon, testLens, testData);
-                fail('Should have thrown an error');
+                // This should throw an error in strict mode
+                await strictHoloSphere.put(testHolon, 'nonExistentLens', testData);
+                // If we get here, the test should fail
+                expect('Expected an error').toBe('but none was thrown');
             } catch (error) {
                 expect(error.message).toBe('Schema required in strict mode');
             }

package/test/delete.test.js

@@ -113,6 +113,7 @@ describe('HoloSphere Deletion Tests', () => {
             // Verify global data exists
             const storedGlobalData = await holoSphere.getGlobal(testGlobalTable, globalData.id);
             expect(storedGlobalData).toBeDefined();
+            console.log(storedGlobalData);
             expect(storedGlobalData.value).toBe(globalData.value);
             
             // Delete global data

package/test/holosphere.test.js

@@ -36,12 +36,12 @@ describe('HoloSphere', () => {
         await holoSphere.deleteAll(testHolon, testLens);
         await holoSphere.deleteAllGlobal('testTable');
         
-        // Close Gun connections
-        if (holoSphere.gun) {
-            holoSphere.gun.off();
+        // Close HoloSphere instances
+        if (holoSphere) {
+            await holoSphere.close();
         }
-        if (strictHoloSphere.gun) {
-            strictHoloSphere.gun.off();
+        if (strictHoloSphere) {
+            await strictHoloSphere.close();
         }
         
         // Wait for connections to close
@@ -167,4 +167,188 @@ describe('HoloSphere', () => {
             expect(deletedResult).toBeNull();
         });
     });
+
+    describe('Schema Functions', () => {
+        test('should set and get a schema', async () => {
+            const schema = {
+                type: 'object',
+                properties: {
+                    id: { type: 'string' },
+                    value: { type: 'string' }
+                },
+                required: ['id', 'value']
+            };
+            
+            await holoSphere.setSchema('testLens', schema);
+            const retrieved = await holoSphere.getSchema('testLens');
+            
+            expect(retrieved).toEqual(schema);
+        });
+        
+        test('should cache schemas when fetched', async () => {
+            const schema = {
+                type: 'object',
+                properties: {
+                    id: { type: 'string' },
+                    test: { type: 'string' }
+                },
+                required: ['id', 'test']
+            };
+            
+            // Clear any existing cache and set up fresh schema
+            holoSphere.clearSchemaCache();
+            await holoSphere.setSchema('cacheTestLens', schema);
+            
+            // Cache should be populated by setSchema
+            expect(holoSphere.schemaCache.has('cacheTestLens')).toBe(true);
+            
+            // Save the getGlobal method to create a spy
+            const originalGetGlobal = holoSphere.getGlobal;
+            let globalCalled = false;
+            
+            // Replace with a spy
+            holoSphere.getGlobal = async (...args) => {
+                globalCalled = true;
+                return originalGetGlobal.apply(holoSphere, args);
+            };
+            
+            // This call should use the cache and not call getGlobal
+            const cachedFetch = await holoSphere.getSchema('cacheTestLens');
+            expect(cachedFetch).toEqual(schema);
+            
+            // Verify getGlobal was not called because we used the cache
+            expect(globalCalled).toBe(false);
+            
+            // Now force a non-cached fetch
+            globalCalled = false;
+            const forcedFetch = await holoSphere.getSchema('cacheTestLens', { useCache: false });
+            expect(forcedFetch).toEqual(schema);
+            
+            // Verify getGlobal was called this time
+            expect(globalCalled).toBe(true);
+            
+            // Restore original method
+            holoSphere.getGlobal = originalGetGlobal;
+        });
+        
+        test('should respect cache max age', async () => {
+            const schema = {
+                type: 'object',
+                properties: {
+                    id: { type: 'string' },
+                    age: { type: 'number' }
+                },
+                required: ['id', 'age']
+            };
+            
+            // Clear any existing cache
+            holoSphere.clearSchemaCache();
+            await holoSphere.setSchema('ageTestLens', schema);
+            
+            // First fetch to populate cache
+            await holoSphere.getSchema('ageTestLens');
+            
+            // Verify cache has the entry now
+            expect(holoSphere.schemaCache.has('ageTestLens')).toBe(true);
+            
+            // Manually set an old timestamp on the cache entry
+            const oldTimestamp = Date.now() - 3700000; // Older than the default maxCacheAge
+            holoSphere.schemaCache.set('ageTestLens', {
+                schema,
+                timestamp: oldTimestamp
+            });
+            
+            // Save the getGlobal method to create a spy
+            const originalGetGlobal = holoSphere.getGlobal;
+            let globalCalled = false;
+            
+            // Replace with a spy
+            holoSphere.getGlobal = async (...args) => {
+                globalCalled = true;
+                return originalGetGlobal.apply(holoSphere, args);
+            };
+            
+            // Call should bypass the cache due to age
+            const secondFetch = await holoSphere.getSchema('ageTestLens');
+            expect(secondFetch).toEqual(schema);
+            
+            // getGlobal should have been called again
+            expect(globalCalled).toBe(true);
+            
+            // Restore original method
+            holoSphere.getGlobal = originalGetGlobal;
+        });
+        
+        test('should clear cache properly', async () => {
+            const schema1 = {
+                type: 'object',
+                properties: { id: { type: 'string' } },
+                required: ['id']
+            };
+            
+            const schema2 = {
+                type: 'object',
+                properties: { name: { type: 'string' } },
+                required: ['name']
+            };
+            
+            // Set two schemas
+            await holoSphere.setSchema('clearTest1', schema1);
+            await holoSphere.setSchema('clearTest2', schema2);
+            
+            // Verify they're cached
+            expect(holoSphere.schemaCache.has('clearTest1')).toBe(true);
+            expect(holoSphere.schemaCache.has('clearTest2')).toBe(true);
+            
+            // Clear one schema
+            holoSphere.clearSchemaCache('clearTest1');
+            expect(holoSphere.schemaCache.has('clearTest1')).toBe(false);
+            expect(holoSphere.schemaCache.has('clearTest2')).toBe(true);
+            
+            // Clear all schemas
+            holoSphere.clearSchemaCache();
+            expect(holoSphere.schemaCache.has('clearTest1')).toBe(false);
+            expect(holoSphere.schemaCache.has('clearTest2')).toBe(false);
+        });
+
+        test('should provide significant performance improvement with caching', async () => {
+            const schema = {
+                type: 'object',
+                properties: {
+                    id: { type: 'string' },
+                    value: { type: 'number' },
+                    name: { type: 'string' }
+                },
+                required: ['id', 'value']
+            };
+            
+            // Set up the schema
+            await holoSphere.setSchema('perfTestLens', schema);
+            
+            // Measure time without caching (force bypass)
+            const start1 = Date.now();
+            for (let i = 0; i < 100; i++) {
+                await holoSphere.getSchema('perfTestLens', { useCache: false });
+            }
+            const end1 = Date.now();
+            const timeWithoutCache = end1 - start1;
+            
+            // Measure time with caching
+            const start2 = Date.now();
+            for (let i = 0; i < 100; i++) {
+                await holoSphere.getSchema('perfTestLens');
+            }
+            const end2 = Date.now();
+            const timeWithCache = end2 - start2;
+            
+            console.log(`Performance comparison:
+                Without cache: ${timeWithoutCache}ms
+                With cache: ${timeWithCache}ms
+                Improvement factor: ${timeWithoutCache / timeWithCache}x
+            `);
+            
+            // The cached version should be at least 2x faster
+            expect(timeWithCache).toBeLessThan(timeWithoutCache / 2);
+        });
+    });
 }); 

package/test/reference.test.js

@@ -0,0 +1,211 @@
+import HoloSphere from '../holosphere.js';
+import { jest } from '@jest/globals';
+
+// Configure timeout
+jest.setTimeout(30000); // 30 second timeout
+
+// Setup
+describe('HoloSphere Reference System', () => {
+    let holoSphere;
+    
+    beforeEach(async () => {
+        // Create a new HoloSphere instance for each test
+        holoSphere = new HoloSphere('testApp');
+    });
+    
+    afterEach(async () => {
+        // Clean up after each test
+        if (holoSphere) {
+            await holoSphere.close();
+            // Wait for connections to close
+            await new Promise(resolve => setTimeout(resolve, 500));
+        }
+    });
+    
+    test('should create and parse a reference correctly', async () => {
+        // Test data
+        const holon = 'testHolon';
+        const lens = 'testLens';
+        const data = {
+            id: 'test-data-123',
+            title: 'Test Data',
+            content: 'This is test content'
+        };
+        
+        // Create a reference
+        const reference = holoSphere.createReference(holon, lens, data);
+        
+        // Validate reference structure
+        expect(reference).toBeTruthy();
+        expect(reference.id).toBe(data.id);
+        expect(reference.soul).toBe(`testApp/${holon}/${lens}/${data.id}`);
+        
+        // Test soul path parsing
+        const soulInfo = holoSphere.parseSoulPath(reference.soul);
+        expect(soulInfo).toBeTruthy();
+        expect(soulInfo.appname).toBe('testApp');
+        expect(soulInfo.holon).toBe(holon);
+        expect(soulInfo.lens).toBe(lens);
+        expect(soulInfo.key).toBe(data.id);
+    });
+    
+    test('should detect different types of references correctly', async () => {
+        // Soul reference
+        const soulReference = {
+            id: 'test-data-123',
+            soul: 'testApp/testHolon/testLens/test-data-123'
+        };
+        
+        // Legacy federation reference
+        const legacyReference = {
+            id: 'test-data-456',
+            _federation: {
+                isReference: true,
+                origin: 'originHolon',
+                lens: 'originLens'
+            }
+        };
+        
+        // Regular data (not a reference)
+        const regularData = {
+            id: 'test-data-789',
+            title: 'Regular Data',
+            content: 'This is not a reference'
+        };
+        
+        // Test reference detection
+        expect(holoSphere.isReference(soulReference)).toBe(true);
+        expect(holoSphere.isReference(legacyReference)).toBe(true);
+        expect(holoSphere.isReference(regularData)).toBe(false);
+        expect(holoSphere.isReference(null)).toBe(false);
+        expect(holoSphere.isReference(undefined)).toBe(false);
+        expect(holoSphere.isReference("not an object")).toBe(false);
+    });
+    
+    test('should store and retrieve references properly', async () => {
+        // Original data
+        const originalData = {
+            id: 'original-123',
+            title: 'Original Data',
+            content: 'This is the original content'
+        };
+        
+        // Store original data
+        await holoSphere.put('originHolon', 'testLens', originalData);
+        
+        // Create a reference to the original data
+        const reference = holoSphere.createReference('originHolon', 'testLens', originalData);
+        
+        // Store the reference in a different holon
+        await holoSphere.put('referenceHolon', 'testLens', reference);
+        
+        // Retrieve the reference with resolution enabled (default)
+        const resolvedData = await holoSphere.get('referenceHolon', 'testLens', 'original-123');
+        
+        // Verify the original data is present
+        expect(resolvedData).toBeTruthy();
+        expect(resolvedData.title).toBe(originalData.title);
+        expect(resolvedData.content).toBe(originalData.content);
+        
+        // Verify the federation metadata is present
+        expect(resolvedData._federation).toBeTruthy();
+        expect(resolvedData._federation.isReference).toBe(true);
+        expect(resolvedData._federation.resolved).toBe(true);
+        expect(resolvedData._federation.soul).toBe(reference.soul);
+        expect(resolvedData._federation.timestamp).toBeGreaterThan(0);
+        
+        // Retrieve the reference without resolution
+        const unresolvedData = await holoSphere.get('referenceHolon', 'testLens', 'original-123', null, { 
+            resolveReferences: false 
+        });
+        
+        // Verify we got the actual reference
+        expect(unresolvedData).toBeTruthy();
+        expect(unresolvedData.id).toBe('original-123');
+        expect(unresolvedData.soul).toBe(reference.soul);
+        expect(unresolvedData.title).toBeUndefined();
+    });
+    
+    test('should update original data and have references reflect the changes', async () => {
+        // Original data
+        const originalData = {
+            id: 'original-456',
+            title: 'Original Data',
+            content: 'This content will be updated'
+        };
+        
+        // Store original data
+        await holoSphere.put('originHolon', 'testLens', originalData);
+        
+        // Create a reference
+        const reference = holoSphere.createReference('originHolon', 'testLens', originalData);
+        
+        // Store the reference in a different holon
+        await holoSphere.put('referenceHolon', 'testLens', reference);
+        
+        // Update the original data
+        const updatedData = {
+            ...originalData,
+            title: 'Updated Data',
+            content: 'This content has been updated'
+        };
+        await holoSphere.put('originHolon', 'testLens', updatedData);
+        
+        // Retrieve the reference 
+        const resolvedData = await holoSphere.get('referenceHolon', 'testLens', 'original-456');
+        
+        // Verify the reference resolves to the updated data
+        expect(resolvedData).toBeTruthy();
+        expect(resolvedData.title).toBe('Updated Data');
+        expect(resolvedData.content).toBe('This content has been updated');
+    });
+    
+    test('should create and use manual references across holons', async () => {
+        // Original data to reference
+        const originalData = {
+            id: 'federated-123',
+            title: 'Federated Data',
+            content: 'This content should be referenced'
+        };
+        
+        // Store original data
+        await holoSphere.put('sourceHolon', 'testLens', originalData);
+        
+        // Create a reference to the original data
+        const reference = holoSphere.createReference('sourceHolon', 'testLens', originalData);
+        
+        // Store reference in the target holon
+        await holoSphere.put('targetHolon', 'testLens', reference);
+        
+        // Retrieve the reference with resolution
+        const resolvedData = await holoSphere.get('targetHolon', 'testLens', 'federated-123');
+        
+        // Verify the reference was resolved to the original data
+        expect(resolvedData).toBeTruthy();
+        expect(resolvedData.title).toBe('Federated Data');
+        expect(resolvedData.content).toBe('This content should be referenced');
+        expect(resolvedData._federation).toBeTruthy();
+        expect(resolvedData._federation.isReference).toBe(true);
+        expect(resolvedData._federation.resolved).toBe(true);
+        expect(resolvedData._federation.soul).toBe(reference.soul);
+        
+        // Update original data
+        const updatedData = {
+            ...originalData,
+            title: 'Updated Data',
+            content: 'This content has been updated'
+        };
+        await holoSphere.put('sourceHolon', 'testLens', updatedData);
+        
+        // Add a delay to ensure data is updated
+        await new Promise(resolve => setTimeout(resolve, 500));
+        
+        // Retrieve the reference again
+        const updatedResolvedData = await holoSphere.get('targetHolon', 'testLens', 'federated-123');
+        
+        // Verify the update was reflected via the reference
+        expect(updatedResolvedData).toBeTruthy();
+        expect(updatedResolvedData.title).toBe('Updated Data');
+        expect(updatedResolvedData.content).toBe('This content has been updated');
+    });
+});