holosphere 1.1.11 → 1.1.12

package/test/hologram-updates.test.js

@@ -0,0 +1,143 @@
+// hologram-updates.test.js
+
+import HoloSphere from '../holosphere.js';
+
+describe('Hologram Update Tests', () => {
+    let holoSphere;
+    const testHolon = 'updateTestHolon';
+    const testLens = 'testLens';
+    const otherLens = 'otherLens';
+    const appName = 'test-hologram-update-app';
+
+    const waitForGun = (ms = 300) => new Promise(resolve => setTimeout(resolve, ms));
+
+    beforeEach(async () => {
+        holoSphere = new HoloSphere(appName, false);
+        // Clean up before each test
+        try {
+            await holoSphere.deleteAll(testHolon, testLens);
+            await holoSphere.deleteAll(testHolon, otherLens);
+        } catch (error) {
+            // Ignore cleanup errors
+        }
+        
+        await waitForGun(100);
+    }, 30000);
+
+    afterEach(async () => {
+        if (holoSphere) {
+            await holoSphere.close();
+        }
+    }, 30000);
+
+    test('should update active holograms when original data is modified', async () => {
+        // 1. Store original data
+        const originalData = { id: 'update-test-item', value: 'Original Value', count: 1 };
+        await holoSphere.put(testHolon, testLens, originalData);
+        await waitForGun();
+
+        // 2. Create and store a hologram pointing to the original data
+        const hologram = holoSphere.createHologram(testHolon, testLens, originalData);
+        await holoSphere.put(testHolon, otherLens, hologram); // Store hologram in different lens
+        await waitForGun(500);
+
+        // 3. Get the hologram before update (should not have 'updated' field)
+        const hologramBeforeUpdate = await holoSphere.get(testHolon, otherLens, originalData.id, null, { resolveHolograms: false });
+        expect(hologramBeforeUpdate).toBeDefined();
+        expect(hologramBeforeUpdate.soul).toBe(hologram.soul);
+        expect(hologramBeforeUpdate.updated).toBeUndefined();
+
+        // 4. Update the original data
+        const updatedData = { id: 'update-test-item', value: 'Updated Value', count: 2 };
+        await holoSphere.put(testHolon, testLens, updatedData);
+        await waitForGun(1000); // Give time for hologram updates to propagate
+
+        // 5. Check that the hologram now has an 'updated' timestamp
+        const hologramAfterUpdate = await holoSphere.get(testHolon, otherLens, originalData.id, null, { resolveHolograms: false });
+        expect(hologramAfterUpdate).toBeDefined();
+        expect(hologramAfterUpdate.soul).toBe(hologram.soul);
+        expect(hologramAfterUpdate.updated).toBeDefined();
+        expect(typeof hologramAfterUpdate.updated).toBe('number');
+        expect(hologramAfterUpdate.updated).toBeGreaterThan(Date.now() - 5000); // Should be recent
+
+        // 6. Verify that resolving the hologram gives the updated data
+        const resolvedData = await holoSphere.get(testHolon, otherLens, originalData.id);
+        expect(resolvedData).toBeDefined();
+        expect(resolvedData.value).toBe('Updated Value');
+        expect(resolvedData.count).toBe(2);
+    });
+
+    test('should update multiple holograms pointing to the same data', async () => {
+        // 1. Store original data
+        const originalData = { id: 'multi-hologram-test', value: 'Original Value' };
+        await holoSphere.put(testHolon, testLens, originalData);
+        await waitForGun();
+
+        // 2. Create and store multiple holograms pointing to the same data
+        const hologram1 = holoSphere.createHologram(testHolon, testLens, originalData);
+        const hologram2 = holoSphere.createHologram(testHolon, testLens, originalData);
+        
+        await holoSphere.put(testHolon, otherLens, { ...hologram1, id: 'hologram-1' });
+        await holoSphere.put(testHolon, otherLens, { ...hologram2, id: 'hologram-2' });
+        await waitForGun(500);
+
+        // 3. Update the original data
+        const updatedData = { id: 'multi-hologram-test', value: 'Updated Value' };
+        await holoSphere.put(testHolon, testLens, updatedData);
+        await waitForGun(1000);
+
+        // 4. Check that both holograms have been updated
+        const updatedHologram1 = await holoSphere.get(testHolon, otherLens, 'hologram-1', null, { resolveHolograms: false });
+        const updatedHologram2 = await holoSphere.get(testHolon, otherLens, 'hologram-2', null, { resolveHolograms: false });
+
+        expect(updatedHologram1.updated).toBeDefined();
+        expect(updatedHologram2.updated).toBeDefined();
+        expect(typeof updatedHologram1.updated).toBe('number');
+        expect(typeof updatedHologram2.updated).toBe('number');
+    });
+
+    test('should not update deleted holograms', async () => {
+        // 1. Store original data
+        const originalData = { id: 'delete-test-item', value: 'Original Value' };
+        await holoSphere.put(testHolon, testLens, originalData);
+        await waitForGun();
+
+        // 2. Create and store a hologram
+        const hologram = holoSphere.createHologram(testHolon, testLens, originalData);
+        await holoSphere.put(testHolon, otherLens, hologram);
+        await waitForGun(500);
+
+        // 3. Delete the hologram
+        await holoSphere.delete(testHolon, otherLens, originalData.id);
+        await waitForGun(500);
+
+        // 4. Update the original data
+        const updatedData = { id: 'delete-test-item', value: 'Updated Value' };
+        await holoSphere.put(testHolon, testLens, updatedData);
+        await waitForGun(1000);
+
+        // 5. Verify the original data was updated
+        const retrievedData = await holoSphere.get(testHolon, testLens, originalData.id);
+        expect(retrievedData.value).toBe('Updated Value');
+
+        // 6. Verify the hologram was not updated (since it's deleted)
+        const deletedHologram = await holoSphere.get(testHolon, otherLens, originalData.id);
+        expect(deletedHologram).toBeNull(); // Should be null since it was deleted
+    });
+
+    test('should work with data that has no holograms', async () => {
+        // 1. Store data that has no holograms pointing to it
+        const originalData = { id: 'no-holograms-test', value: 'Original Value' };
+        await holoSphere.put(testHolon, testLens, originalData);
+        await waitForGun();
+
+        // 2. Update the data (should not cause errors even with no holograms)
+        const updatedData = { id: 'no-holograms-test', value: 'Updated Value' };
+        await holoSphere.put(testHolon, testLens, updatedData);
+        await waitForGun(1000);
+
+        // 3. Verify the data was updated successfully
+        const retrievedData = await holoSphere.get(testHolon, testLens, originalData.id);
+        expect(retrievedData.value).toBe('Updated Value');
+    });
+}); 

package/test/hologram.test.js

@@ -297,7 +297,7 @@ describe('HoloSphere Reference System', () => {
         const targetNodeRef = holoSphere.getNodeRef(targetSoul);
         let hologramsSet = await new Promise(resolve => targetNodeRef.get('_holograms').once(resolve));
         expect(hologramsSet).toBeDefined();
-        expect(hologramsSet[storedHologramSoul]).toBe(true);
+        expect(hologramsSet[storedHologramSoul]).toBeDefined(); // Hologram should be tracked initially
 
         // 4. Delete the hologram
         await holoSphere.delete(testHolon, 'otherLens', 'hologram-tracker-2');
@@ -307,9 +307,9 @@ describe('HoloSphere Reference System', () => {
         // 5. Fetch the _holograms set again directly
         hologramsSet = await new Promise(resolve => targetNodeRef.get('_holograms').once(resolve));
 
-        // 6. Verify the hologram's soul is marked as 'DELETED'
+        // 6. Verify the hologram's soul is completely removed (or set to null by Gun)
         expect(hologramsSet).toBeDefined();
-        expect(hologramsSet[storedHologramSoul]).toBe('DELETED'); // <-- Expect 'DELETED' string
+        expect(hologramsSet[storedHologramSoul]).toBeNull(); // Gun stores null when we put(null)
     });
     // --- End tests for _holograms tracking ---
 

package/test/meta-strip.test.js

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

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