holosphere 1.1.12 → 1.1.13

package/test/holosphere.test.js

@@ -1,354 +0,0 @@
-import HoloSphere from '../holosphere.js';
-import * as h3 from 'h3-js';
-import { jest } from '@jest/globals';
-
-// Configure Jest
-jest.setTimeout(30000); // 30 second timeout
-
-describe('HoloSphere', () => {
-    const testAppName = 'test-app3';
-    const testHolon = 'testHolon3';
-    const testLens = 'testLens3';
-    const testPassword = 'testPassword1234';
-    let holoSphere;
-    let strictHoloSphere;
-    beforeAll(async () => {
-        holoSphere = new HoloSphere('test-app', false, null);
-        strictHoloSphere = new HoloSphere('test-app-strict', true, null);
-    });
-
-    afterEach(async () => {
-        // Clean up test data
-        try {
-            if (holoSphere) {
-                await holoSphere.deleteAll(testHolon, testLens);
-            }
-            if (strictHoloSphere) {
-                await strictHoloSphere.deleteAll(testHolon, testLens);
-            }
-        } catch (error) {
-            console.error('Error in afterEach cleanup:', error);
-        }
-    });
-
-    afterAll(async () => {
-        // Clean up all test data
-        await holoSphere.deleteAll(testHolon, testLens);
-        await holoSphere.deleteAllGlobal('testTable');
-        
-        // Close HoloSphere instances
-        if (holoSphere) {
-            await holoSphere.close();
-        }
-        if (strictHoloSphere) {
-            await strictHoloSphere.close();
-        }
-        
-        // Wait for connections to close
-        await new Promise(resolve => setTimeout(resolve, 1000));
-    });
-
-
-    describe('Constructor', () => {
-        test('should have initialized with correct properties', () => {
-            expect(holoSphere).toBeInstanceOf(HoloSphere);
-            expect(holoSphere.gun).toBeDefined();
-            expect(holoSphere.validator).toBeDefined();
-            expect(holoSphere.openai).toBeUndefined();
-            expect(holoSphere.subscriptions).toBeDefined();
-            expect(holoSphere.subscriptions).toEqual({});
-        });
-
-        test('should initialize with OpenAI', () => {
-            expect(new HoloSphere(testAppName, false, 'fake-key').openai).toBeDefined();
-        });
-    });
-
-    describe('Space Management', () => {
-        test('should handle private space authentication', async () => {
-            const testData = { id: 'test1', value: 'data' + Date.now() };
-            
-            await holoSphere.put(testHolon, testLens, testData, testPassword);
-            const result = await holoSphere.get(testHolon, testLens, testData.id, testPassword);
-            expect(result).toBeDefined();
-            expect(result.value).toBe(testData.value);
-        });
-
-        test('should handle public space access', async () => {
-            const testData = { id: 'public1', value: 'public data' + Date.now() };
-            
-            await holoSphere.put(testHolon, testLens, testData);
-            const result = await holoSphere.get(testHolon, testLens, testData.id);
-            expect(result).toBeDefined();
-            expect(result.value).toBe(testData.value);
-        });
-
-        test('should handle missing parameters gracefully', async () => {
-            const result1 = await holoSphere.get(null, testLens, 'key');
-            expect(result1).toBeNull();
-
-            const result2 = await holoSphere.get(testHolon, null, 'key');
-            expect(result2).toBeNull();
-
-            const result3 = await holoSphere.get(testHolon, testLens, null);
-            expect(result3).toBeNull();
-        });
-
-        test('should handle authentication errors gracefully', async () => {
-            const testData = { id: 'test2', value: 'private data' };
-            
-            await holoSphere.put(testHolon, testLens, testData, testPassword);
-            const result = await holoSphere.get(testHolon, testLens, testData.id, 'wrong_password');
-            expect(result).toBeNull();
-        });
-    });
-
-    describe('Data Operations', () => {
-        const validSchema = {
-            type: 'object',
-            properties: {
-                id: { type: 'string' },
-                value: { type: 'string' }
-            },
-            required: ['id', 'value']
-        };
-
-        beforeEach(async () => {
-            await holoSphere.setSchema(testLens, validSchema);
-        });
-
-        test('should handle data operations gracefully', async () => {
-            const testData = { id: 'test3', value: 'test data' };
-            
-            // Test non-existent data
-            const nonExistent = await holoSphere.get(testHolon, testLens, 'non-existent');
-            expect(nonExistent).toBeNull();
-
-            // Test storing and retrieving data
-            await holoSphere.put(testHolon, testLens, testData);
-            const result = await holoSphere.get(testHolon, testLens, testData.id);
-            expect(result).toEqual(testData);
-
-            // Test deleting data
-            await holoSphere.delete(testHolon, testLens, testData.id);
-            const deletedResult = await holoSphere.get(testHolon, testLens, testData.id);
-            expect(deletedResult).toBeNull();
-        });
-
-        test('should handle invalid data gracefully', async () => {
-            const invalidData = { wrongField: 'no id field' };
-            
-            // Should not throw when storing invalid data in non-strict mode
-            await expect(holoSphere.put(testHolon, testLens, invalidData))
-                .resolves.toBeTruthy();
-
-            // Should return null when retrieving invalid data
-            const result = await holoSphere.get(testHolon, testLens, 'undefined');
-            expect(result).toBeNull();
-        });
-    });
-
-    describe('Global Operations', () => {
-        test('should handle global operations gracefully', async () => {
-            const globalData = { id: 'global1', value: 'global test data' };
-            
-            // Test non-existent data
-            const nonExistent = await holoSphere.getGlobal(testHolon, testLens, 'non-existent');
-            expect(nonExistent).toBeNull();
-
-            // Test storing and retrieving data
-            await holoSphere.putGlobal(testLens, globalData);
-            const result = await holoSphere.getGlobal(testLens, globalData.id);
-            expect(result).toEqual(globalData);
-
-            // Test deleting data
-            await holoSphere.deleteGlobal( testLens, globalData.id);
-            const deletedResult = await holoSphere.getGlobal( testLens, globalData.id);
-            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/meta-strip.test.js

@@ -1,159 +0,0 @@
-// meta-strip.test.js
-
-import HoloSphere from '../holosphere.js';
-
-describe('Meta Field Stripping Tests', () => {
-    let holoSphere;
-    const testHolon = 'testHolon';
-    const testLens = 'testLens';
-    const testGlobalTable = 'testGlobalTable';
-
-    beforeEach(async () => {
-        holoSphere = new HoloSphere('test_app', false);
-        // Clean up before each test
-        try {
-            await holoSphere.deleteAll(testHolon, testLens);
-            await holoSphere.deleteAllGlobal(testGlobalTable);
-        } catch (error) {
-            // Ignore cleanup errors
-        }
-        
-        // Small wait for Gun to settle
-        await new Promise(resolve => setTimeout(resolve, 100));
-    }, 30000);
-
-    afterEach(async () => {
-        if (holoSphere) {
-            await holoSphere.close();
-        }
-    }, 30000);
-
-    describe('put() should strip _meta field', () => {
-        test('should not store _meta field when putting data', async () => {
-            const testData = {
-                id: 'test1',
-                name: 'Test Item',
-                value: 42,
-                _meta: {
-                    resolvedFromHologram: true,
-                    hologramSoul: 'app/holon/lens/key',
-                    someOtherMeta: 'should not be stored'
-                }
-            };
-
-            // Store the data (should strip _meta)
-            await holoSphere.put(testHolon, testLens, testData);
-            
-            // Wait for Gun to settle
-            await new Promise(resolve => setTimeout(resolve, 500));
-
-            // Retrieve the data
-            const retrieved = await holoSphere.get(testHolon, testLens, testData.id);
-
-            // Verify data exists and _meta is not stored
-            expect(retrieved).not.toBeNull();
-            expect(retrieved.id).toBe(testData.id);
-            expect(retrieved.name).toBe(testData.name);
-            expect(retrieved.value).toBe(testData.value);
-            expect(retrieved._meta).toBeUndefined(); // _meta should not be stored
-        });
-
-        test('should handle data without _meta field normally', async () => {
-            const testData = {
-                id: 'test2',
-                name: 'Test Item Without Meta',
-                value: 99
-            };
-
-            // Store the data
-            await holoSphere.put(testHolon, testLens, testData);
-            
-            // Wait for Gun to settle
-            await new Promise(resolve => setTimeout(resolve, 500));
-
-            // Retrieve the data
-            const retrieved = await holoSphere.get(testHolon, testLens, testData.id);
-
-            // Verify data exists and matches exactly
-            expect(retrieved).toEqual(testData);
-            expect(retrieved._meta).toBeUndefined();
-        });
-    });
-
-    describe('putGlobal() should strip _meta field', () => {
-        test('should not store _meta field when putting global data', async () => {
-            const testData = {
-                id: 'globaltest1',
-                name: 'Global Test Item',
-                value: 123,
-                _meta: {
-                    resolvedFromHologram: true,
-                    hologramSoul: 'app/holon/lens/key',
-                    federation: { origin: 'someholon' }
-                }
-            };
-
-            // Store the global data (should strip _meta)
-            await holoSphere.putGlobal(testGlobalTable, testData);
-            
-            // Wait for Gun to settle
-            await new Promise(resolve => setTimeout(resolve, 500));
-
-            // Retrieve the data
-            const retrieved = await holoSphere.getGlobal(testGlobalTable, testData.id);
-
-            // Verify data exists and _meta is not stored
-            expect(retrieved).not.toBeNull();
-            expect(retrieved.id).toBe(testData.id);
-            expect(retrieved.name).toBe(testData.name);
-            expect(retrieved.value).toBe(testData.value);
-            expect(retrieved._meta).toBeUndefined(); // _meta should not be stored
-        });
-
-        test('should handle global data without _meta field normally', async () => {
-            const testData = {
-                id: 'globaltest2',
-                name: 'Global Test Item Without Meta',
-                value: 456
-            };
-
-            // Store the global data
-            await holoSphere.putGlobal(testGlobalTable, testData);
-            
-            // Wait for Gun to settle
-            await new Promise(resolve => setTimeout(resolve, 500));
-
-            // Retrieve the data
-            const retrieved = await holoSphere.getGlobal(testGlobalTable, testData.id);
-
-            // Verify data exists and matches exactly
-            expect(retrieved).toEqual(testData);
-            expect(retrieved._meta).toBeUndefined();
-        });
-    });
-
-    test('should preserve _meta in original data object (not mutate input)', async () => {
-        const testData = {
-            id: 'test3',
-            name: 'Test Mutation',
-            _meta: {
-                resolvedFromHologram: true,
-                hologramSoul: 'app/holon/lens/key'
-            }
-        };
-
-        // Store a copy to verify original isn't mutated
-        const originalMeta = { ...testData._meta };
-
-        // Store the data
-        await holoSphere.put(testHolon, testLens, testData);
-
-        // Verify the original object still has _meta (we shouldn't mutate the input)
-        expect(testData._meta).toBeDefined();
-        expect(testData._meta).toEqual(originalMeta);
-
-        // But the stored data should not have _meta
-        const retrieved = await holoSphere.get(testHolon, testLens, testData.id);
-        expect(retrieved._meta).toBeUndefined();
-    });
-}); 

package/test/parent-propagation.test.js

@@ -1,138 +0,0 @@
-import HoloSphere from '../holosphere.js';
-
-describe('Parent Propagation Tests', () => {
-  let holosphere;
-  const testPrefix = 'parent_prop_test_';
-
-  beforeEach(() => {
-    holosphere = new HoloSphere('parent-propagation-test');
-  });
-
-  afterEach(async () => {
-    if (holosphere) {
-      await holosphere.close();
-    }
-  });
-
-  describe('propagate with parent propagation', () => {
-    test('should propagate to parent hexagons when holon is valid H3 hexagon', async () => {
-      // Create a valid H3 hexagon (resolution 7)
-      const childHexagon = '87283472bffffff'; // Example H3 hexagon at resolution 7
-      const parentHexagon = '86283472fffffff'; // Parent at resolution 6
-      
-      // Test data
-      const testData = {
-        id: 'test-item-1',
-        title: 'Test Item',
-        value: 42
-      };
-
-      // Propagate with parent propagation enabled
-      const result = await holosphere.propagate(childHexagon, 'items', testData, {
-        propagateToParents: true,
-        maxParentLevels: 5
-      });
-
-      // Check that parent propagation was attempted
-      expect(result.parentPropagation).toBeDefined();
-      expect(result.parentPropagation.success).toBeGreaterThan(0);
-      expect(result.parentPropagation.messages).toEqual(
-        expect.arrayContaining([expect.stringContaining('parent hexagons to propagate to')])
-      );
-
-      // Allow time for propagation
-      await new Promise(resolve => setTimeout(resolve, 1000));
-
-      // Verify data was propagated to parent hexagon (check for hologram, not resolved data)
-      const parentHologram = await holosphere.get(parentHexagon, 'items', testData.id, null, { resolveHolograms: false });
-      expect(parentHologram).toBeDefined();
-      expect(parentHologram._federation.propagationType).toBe('parent');
-    });
-
-    test('should skip parent propagation for non-H3 hexagons', async () => {
-      // Use a non-H3 hexagon identifier
-      const nonHexagonHolon = 'not-a-hexagon';
-      
-      const testData = {
-        id: 'test-item-2',
-        title: 'Test Item',
-        value: 42
-      };
-
-      const result = await holosphere.propagate(nonHexagonHolon, 'items', testData, {
-        propagateToParents: true
-      });
-
-      expect(result.parentPropagation).toBeDefined();
-      expect(result.parentPropagation.skipped).toBe(1);
-      expect(result.parentPropagation.messages).toEqual(
-        expect.arrayContaining([expect.stringContaining('No parent hexagons found')])
-      );
-    });
-
-    test('should respect maxParentLevels option', async () => {
-      const childHexagon = '87283472bffffff'; // Resolution 7
-      
-      const testData = {
-        id: 'test-item-3',
-        title: 'Test Item',
-        value: 42
-      };
-
-      const result = await holosphere.propagate(childHexagon, 'items', testData, {
-        propagateToParents: true,
-        maxParentLevels: 2 // Only propagate to 2 parent levels
-      });
-
-      expect(result.parentPropagation).toBeDefined();
-      expect(result.parentPropagation.success).toBe(2); // Should propagate to 2 parent levels
-    });
-
-    test('should disable parent propagation when propagateToParents is false', async () => {
-      const childHexagon = '87283472bffffff';
-      
-      const testData = {
-        id: 'test-item-4',
-        title: 'Test Item',
-        value: 42
-      };
-
-      const result = await holosphere.propagate(childHexagon, 'items', testData, {
-        propagateToParents: false
-      });
-
-      expect(result.parentPropagation).toBeDefined();
-      expect(result.parentPropagation.success).toBe(0);
-      expect(result.parentPropagation.skipped).toBe(0);
-    });
-
-    test('should include parent level information in federation metadata', async () => {
-      const childHexagon = '87283472bffffff'; // Resolution 7
-      const parentHexagon = '86283472fffffff'; // Resolution 6
-      
-      const testData = {
-        id: 'test-item-5',
-        title: 'Test Item',
-        value: 42
-      };
-
-      // First, store the original data in the child hexagon
-      await holosphere.put(childHexagon, 'items', testData);
-
-      // Then propagate to parent
-      await holosphere.propagate(childHexagon, 'items', testData, {
-        propagateToParents: true,
-        maxParentLevels: 1
-      });
-
-      // Allow time for propagation
-      await new Promise(resolve => setTimeout(resolve, 1000));
-
-      // Check parent data has correct metadata (check for hologram, not resolved data)
-      const parentHologram = await holosphere.get(parentHexagon, 'items', testData.id, null, { resolveHolograms: false });
-      expect(parentHologram).toBeDefined();
-      expect(parentHologram._federation.propagationType).toBe('parent');
-      expect(parentHologram._federation.parentLevel).toBe(1); // 1 level up from resolution 7 to 6
-    });
-  });
-});