holosphere 1.1.11 → 1.1.12

package/holosphere.d.ts

@@ -8,6 +8,10 @@ interface PropagationOptions {
   targetSpaces?: string[];
   /** Password for accessing the source holon (if needed) */
   password?: string | null;
+  /** Whether to automatically propagate to parent hexagons (default: true) */
+  propagateToParents?: boolean;
+  /** Maximum number of parent levels to propagate to (default: 15) */
+  maxParentLevels?: number;
 }
 
 /**
@@ -113,6 +117,17 @@ interface PropagationResult {
   error?: string;
   /** Information message if applicable */
   message?: string;
+  /** Parent propagation results */
+  parentPropagation?: {
+    /** Number of successfully propagated items to parents */
+    success: number;
+    /** Number of errors encountered during parent propagation */
+    errors: number;
+    /** Number of parent propagations skipped */
+    skipped: number;
+    /** Messages from parent propagation */
+    messages: string[];
+  };
 }
 
 /**

package/holosphere.js

@@ -1,6 +1,6 @@
 /**
  * @module holosphere
- * @version 1.1.11
+ * @version 1.1.12
  * @description Holonic Geospatial Communication Infrastructure
  * @author Roberto Valenti
  * @license GPL-3.0-or-later
@@ -20,7 +20,7 @@ import * as ComputeOps from './compute.js';
 import * as Utils from './utils.js';
 
 // Define the version constant
-const HOLOSPHERE_VERSION = '1.1.11'; 
+const HOLOSPHERE_VERSION = '1.1.12'; 
 
 class HoloSphere {
     /**

package/node.js

@@ -18,6 +18,10 @@ export async function putNode(holoInstance, holon, lens, data) {
             // if (data && data.isHologram !== undefined) {
             // delete data.isHologram;
             // }
+            
+            // Check if the data being stored is a hologram
+            const isHologram = data.value && holoInstance.isHologram(data.value);
+            
             holoInstance.gun.get(holoInstance.appname)
                 .get(holon)
                 .get(lens)
@@ -26,6 +30,27 @@ export async function putNode(holoInstance, holon, lens, data) {
                     if (ack.err) {
                         reject(new Error(ack.err));
                     } else {
+                        // --- Start: Hologram Tracking Logic (for data *being put*, if it's a hologram) ---
+                        if (isHologram) {
+                            try {
+                                const storedDataSoulInfo = holoInstance.parseSoulPath(data.value.soul);
+                                if (storedDataSoulInfo) {
+                                    const targetNodeRef = holoInstance.getNodeRef(data.value.soul); // Target of the data *being put*
+                                    // Soul of the hologram that was *actually stored* at holon/lens/value
+                                    const storedHologramInstanceSoul = `${holoInstance.appname}/${holon}/${lens}/value`;
+                                    
+                                    targetNodeRef.get('_holograms').get(storedHologramInstanceSoul).put(true);
+                                    
+                                    console.log(`Data (ID: ${data.id}) being put is a hologram. Added its instance soul ${storedHologramInstanceSoul} to its target ${data.value.soul}'s _holograms set.`);
+                                } else {
+                                    console.warn(`Data (ID: ${data.id}) being put is a hologram, but could not parse its soul ${data.value.soul} for tracking.`);
+                                }
+                            } catch (trackingError) {
+                                console.warn(`Error updating _holograms set for the target of the data being put (data ID: ${data.id}, soul: ${data.value.soul}):`, trackingError);
+                            }
+                        }
+                        // --- End: Hologram Tracking Logic ---
+                        
                         resolve(true);
                     }
                 });
@@ -139,17 +164,77 @@ export async function deleteNode(holoInstance, holon, lens, key) {
     if (!holon || !lens || !key) {
         throw new Error('deleteNode: Missing required parameters');
     }
-    return new Promise((resolve, reject) => {
-        holoInstance.gun.get(holoInstance.appname)
-            .get(holon)
-            .get(lens)
-            .get(key)
-            .put(null, ack => {
+
+    try {
+        const dataPath = holoInstance.gun.get(holoInstance.appname).get(holon).get(lens).get(key);
+
+        // --- Start: Hologram Tracking Removal ---
+        let trackingRemovalPromise = Promise.resolve(); // Default to resolved promise
+        
+        // 1. Get the data first to check if it's a hologram
+        const rawDataToDelete = await new Promise((resolve) => dataPath.once(resolve));
+        let dataToDelete = null;
+        try {
+            if (typeof rawDataToDelete === 'string') {
+                dataToDelete = JSON.parse(rawDataToDelete);
+            } else {
+                // Handle cases where it might already be an object (though likely string)
+                dataToDelete = rawDataToDelete; 
+            }
+        } catch(e) {
+            console.warn("[deleteNode] Could not JSON parse data for deletion check:", rawDataToDelete, e);
+            dataToDelete = null; // Ensure it's null if parsing fails
+        }
+
+        // 2. If it is a hologram, try to remove its reference from the target
+        const isDataHologram = dataToDelete && holoInstance.isHologram(dataToDelete);
+        
+        if (isDataHologram) {
+            try {
+                const targetSoul = dataToDelete.soul;
+                const targetSoulInfo = holoInstance.parseSoulPath(targetSoul);
+                
+                if (targetSoulInfo) {
+                    const targetNodeRef = holoInstance.getNodeRef(targetSoul);
+                    // putNode stores at the 'value' key, not at the data.id key
+                    const deletedHologramSoul = `${holoInstance.appname}/${holon}/${lens}/value`;
+
+                    // Create a promise that resolves when the hologram is removed from the list
+                    trackingRemovalPromise = new Promise((resolveTrack) => { // No reject needed, just warn on error
+                        targetNodeRef.get('_holograms').get(deletedHologramSoul).put(null, (ack) => { // Remove the hologram entry completely
+                            if (ack.err) {
+                                console.warn(`[deleteNode] Error removing hologram ${deletedHologramSoul} from target ${targetSoul}:`, ack.err);
+                            }
+                            console.log(`Removed hologram ${deletedHologramSoul} from target ${targetSoul}'s _holograms list`);
+                            resolveTrack(); // Resolve regardless of ack error to not block main delete
+                        });
+                    });
+                } else {
+                    console.warn(`Could not parse target soul ${targetSoul} for hologram tracking removal during deleteNode.`);
+                }
+            } catch (trackingError) {
+                console.warn(`Error initiating hologram reference removal from target ${dataToDelete.soul} during deleteNode:`, trackingError);
+                // Ensure trackingRemovalPromise remains resolved if setup fails
+                trackingRemovalPromise = Promise.resolve(); 
+            }
+        }
+        // --- End: Hologram Tracking Removal ---
+
+        // 3. Wait for the tracking removal attempt to be acknowledged
+        await trackingRemovalPromise;
+
+        // 4. Proceed with the actual deletion of the hologram node itself
+        return new Promise((resolve, reject) => {
+            dataPath.put(null, ack => {
                 if (ack.err) {
                     reject(new Error(ack.err));
                 } else {
                     resolve(true);
                 }
             });
-    });
+        });
+    } catch (error) {
+        console.error('Error in deleteNode:', error);
+        throw error;
+    }
 } 

package/package.json

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

package/test/hologram-deletion.test.js

@@ -0,0 +1,197 @@
+/**
+ * Tests for hologram deletion functionality
+ * Verifies that when deleting holograms, only the hologram is deleted and the target's _holograms list is updated
+ * The original data should remain intact
+ */
+
+import HoloSphere from '../holosphere.js';
+
+const appName = 'test-hologram-deletion-app';
+const testHolon = 'hologramDeletionTestHolon';
+const testLens = 'testLens';
+const otherLens = 'otherLens';
+
+const waitForGun = (delay = 250) => new Promise(resolve => setTimeout(resolve, delay));
+
+describe('Hologram Deletion Tests', () => {
+    let holoSphere;
+
+    beforeEach(async () => {
+        holoSphere = new HoloSphere(appName, false);
+        await waitForGun();
+    });
+
+    afterEach(async () => {
+        if (holoSphere) {
+            await holoSphere.close();
+        }
+        await waitForGun();
+    });
+
+    test('delete() should only delete hologram and update target _holograms list', async () => {
+        // 1. Store original data
+        const originalData = { id: 'original-data-1', value: 'Original content' };
+        await holoSphere.put(testHolon, testLens, originalData);
+        await waitForGun();
+        const originalSoul = `${appName}/${testHolon}/${testLens}/original-data-1`;
+
+        // 2. Store a hologram pointing to the original data
+        const hologramData = holoSphere.createHologram(testHolon, testLens, originalData);
+        const hologramStorage = { id: 'hologram-to-delete', soul: hologramData.soul };
+        await holoSphere.put(testHolon, otherLens, hologramStorage);
+        await waitForGun(500);
+        const hologramSoul = `${appName}/${testHolon}/${otherLens}/hologram-to-delete`;
+
+        // 3. Verify hologram was added to tracking initially
+        const targetNodeRef = holoSphere.getNodeRef(originalSoul);
+        let hologramsSet = await new Promise(resolve => targetNodeRef.get('_holograms').once(resolve));
+        expect(hologramsSet).toBeDefined();
+        expect(hologramsSet[hologramSoul]).toBeDefined();
+
+        // 4. Delete the hologram
+        await holoSphere.delete(testHolon, otherLens, 'hologram-to-delete');
+        await waitForGun(1000);
+
+        // 5. Verify the hologram is deleted
+        const deletedHologram = await holoSphere.get(testHolon, otherLens, 'hologram-to-delete');
+        expect(deletedHologram).toBeNull();
+
+        // 6. Verify the original data still exists
+        const originalStillExists = await holoSphere.get(testHolon, testLens, 'original-data-1');
+        expect(originalStillExists).toBeDefined();
+        expect(originalStillExists.value).toBe('Original content');
+
+        // 7. Verify the hologram was removed from target's _holograms list
+        hologramsSet = await new Promise(resolve => targetNodeRef.get('_holograms').once(resolve));
+        expect(hologramsSet[hologramSoul]).toBeNull();
+    }, 15000);
+
+    test('deleteAll() should handle holograms properly', async () => {
+        // 1. Store original data
+        const originalData = { id: 'original-data-2', value: 'Original content' };
+        await holoSphere.put(testHolon, testLens, originalData);
+        await waitForGun();
+        const originalSoul = `${appName}/${testHolon}/${testLens}/original-data-2`;
+
+        // 2. Store just one hologram in otherLens (simplified test)
+        const hologramData = holoSphere.createHologram(testHolon, testLens, originalData);
+        const hologramStorage = { id: 'hologram-in-deleteall', soul: hologramData.soul };
+        await holoSphere.put(testHolon, otherLens, hologramStorage);
+        await waitForGun(500);
+        const hologramSoul = `${appName}/${testHolon}/${otherLens}/hologram-in-deleteall`;
+
+        // 3. Verify hologram was added to tracking initially
+        const targetNodeRef = holoSphere.getNodeRef(originalSoul);
+        let hologramsSet = await new Promise(resolve => targetNodeRef.get('_holograms').once(resolve));
+        expect(hologramsSet).toBeDefined();
+        expect(hologramsSet[hologramSoul]).toBeDefined();
+
+        // 4. Delete all items from otherLens
+        await holoSphere.deleteAll(testHolon, otherLens);
+        await waitForGun(1000);
+
+        // 5. Verify all items in otherLens are deleted
+        const allItems = await holoSphere.getAll(testHolon, otherLens);
+        expect(allItems).toHaveLength(0);
+
+        // 6. Verify the original data still exists
+        const originalStillExists = await holoSphere.get(testHolon, testLens, 'original-data-2');
+        expect(originalStillExists).toBeDefined();
+        expect(originalStillExists.value).toBe('Original content');
+
+        // 7. Verify the hologram was removed from target's _holograms list
+        hologramsSet = await new Promise(resolve => targetNodeRef.get('_holograms').once(resolve));
+        expect(hologramsSet[hologramSoul]).toBeNull();
+    }, 15000);
+
+    test('deleteGlobal() should handle holograms properly', async () => {
+        // 1. Store original data
+        const originalData = { id: 'original-data-3', value: 'Original content' };
+        await holoSphere.put(testHolon, testLens, originalData);
+        await waitForGun();
+        const originalSoul = `${appName}/${testHolon}/${testLens}/original-data-3`;
+
+        // 2. Store a hologram in global table
+        const hologramData = holoSphere.createHologram(testHolon, testLens, originalData);
+        const hologramStorage = { id: 'hologram-in-global', soul: hologramData.soul };
+        await holoSphere.putGlobal('testTable', hologramStorage);
+        await waitForGun(500);
+        const hologramSoul = `${appName}/testTable/hologram-in-global`;
+
+        // 3. Verify hologram was added to tracking initially
+        const targetNodeRef = holoSphere.getNodeRef(originalSoul);
+        let hologramsSet = await new Promise(resolve => targetNodeRef.get('_holograms').once(resolve));
+        expect(hologramsSet).toBeDefined();
+        expect(hologramsSet[hologramSoul]).toBeDefined();
+
+        // 4. Delete the hologram from global table
+        await holoSphere.deleteGlobal('testTable', 'hologram-in-global');
+        await waitForGun(1000);
+
+        // 5. Verify the hologram is deleted
+        const deletedHologram = await holoSphere.getGlobal('testTable', 'hologram-in-global');
+        expect(deletedHologram).toBeNull();
+
+        // 6. Verify the original data still exists
+        const originalStillExists = await holoSphere.get(testHolon, testLens, 'original-data-3');
+        expect(originalStillExists).toBeDefined();
+        expect(originalStillExists.value).toBe('Original content');
+
+        // 7. Verify the hologram was removed from target's _holograms list
+        hologramsSet = await new Promise(resolve => targetNodeRef.get('_holograms').once(resolve));
+        expect(hologramsSet[hologramSoul]).toBeNull();
+    }, 15000);
+
+    test('deleteAllGlobal() should handle holograms properly', async () => {
+        // 1. Store original data
+        const originalData = { id: 'original-data-4', value: 'Original content' };
+        await holoSphere.put(testHolon, testLens, originalData);
+        await waitForGun();
+        const originalSoul = `${appName}/${testHolon}/${testLens}/original-data-4`;
+
+        // 2. Store just one hologram in global table (simplified test)
+        const hologramData = holoSphere.createHologram(testHolon, testLens, originalData);
+        const hologramStorage = { id: 'hologram-in-deleteallglobal', soul: hologramData.soul };
+        await holoSphere.putGlobal('testTable2', hologramStorage);
+        await waitForGun(500);
+        const hologramSoul = `${appName}/testTable2/hologram-in-deleteallglobal`;
+
+        // 3. Verify hologram was added to tracking initially
+        const targetNodeRef = holoSphere.getNodeRef(originalSoul);
+        let hologramsSet = await new Promise(resolve => targetNodeRef.get('_holograms').once(resolve));
+        expect(hologramsSet).toBeDefined();
+        expect(hologramsSet[hologramSoul]).toBeDefined();
+
+        // 4. Delete all items from global table
+        await holoSphere.deleteAllGlobal('testTable2');
+        await waitForGun(1000);
+
+        // 5. Verify all items in global table are deleted
+        const allItems = await holoSphere.getAllGlobal('testTable2');
+        expect(allItems).toHaveLength(0);
+
+        // 6. Verify the original data still exists
+        const originalStillExists = await holoSphere.get(testHolon, testLens, 'original-data-4');
+        expect(originalStillExists).toBeDefined();
+        expect(originalStillExists.value).toBe('Original content');
+
+        // 7. Verify the hologram was removed from target's _holograms list
+        hologramsSet = await new Promise(resolve => targetNodeRef.get('_holograms').once(resolve));
+        expect(hologramsSet[hologramSoul]).toBeNull();
+    }, 15000);
+
+    test('deleting non-hologram data should work normally', async () => {
+        // 1. Store regular data
+        const regularData = { id: 'regular-data-to-delete', value: 'Regular content' };
+        await holoSphere.put(testHolon, testLens, regularData);
+        await waitForGun();
+
+        // 2. Delete the regular data
+        await holoSphere.delete(testHolon, testLens, 'regular-data-to-delete');
+        await waitForGun();
+
+        // 3. Verify the data is deleted
+        const deletedData = await holoSphere.get(testHolon, testLens, 'regular-data-to-delete');
+        expect(deletedData).toBeNull();
+    }, 10000);
+}); 

package/test/hologram-updates-return.test.js

@@ -0,0 +1,166 @@
+// hologram-updates-return.test.js
+
+import HoloSphere from '../holosphere.js';
+
+describe('Hologram Updates Return Value Tests', () => {
+    let holoSphere;
+    const testHolon = 'updateReturnTestHolon';
+    const testLens = 'testLens';
+    const otherLens = 'otherLens';
+    const appName = 'test-hologram-return-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();
+        }
+    });
+
+    test('put should return empty array when no holograms exist', async () => {
+        const originalData = { id: 'no-holograms-test', value: 'Original Value' };
+        
+        // Put original data
+        const result = await holoSphere.put(testHolon, testLens, originalData);
+        
+        expect(result).toBeDefined();
+        expect(result.success).toBe(true);
+        expect(result.updatedHolograms).toBeDefined();
+        expect(Array.isArray(result.updatedHolograms)).toBe(true);
+        expect(result.updatedHolograms).toHaveLength(0);
+    });
+
+    test('put should return list of updated holograms when they exist', async () => {
+        const originalData = { id: 'with-holograms-test', value: 'Original Value' };
+        
+        // Step 1: Put original data
+        await holoSphere.put(testHolon, testLens, originalData);
+        await waitForGun();
+        
+        // Step 2: Create holograms pointing to the original data
+        const hologram1 = holoSphere.createHologram(testHolon, testLens, originalData);
+        const hologram2 = holoSphere.createHologram(testHolon, testLens, originalData);
+        
+        await holoSphere.put(testHolon, otherLens, { id: 'hologram-1', soul: hologram1.soul });
+        await holoSphere.put(testHolon, otherLens, { id: 'hologram-2', soul: hologram2.soul });
+        await waitForGun(500);
+        
+        // Step 3: Update the original data and check the return value
+        const updatedData = { ...originalData, value: 'Updated Value', count: 42 };
+        const result = await holoSphere.put(testHolon, testLens, updatedData);
+        
+        expect(result).toBeDefined();
+        expect(result.success).toBe(true);
+        expect(result.updatedHolograms).toBeDefined();
+        expect(Array.isArray(result.updatedHolograms)).toBe(true);
+        expect(result.updatedHolograms.length).toBeGreaterThan(0);
+        
+        // Check that the returned hologram info is complete
+        result.updatedHolograms.forEach(hologram => {
+            expect(hologram.soul).toBeDefined();
+            expect(hologram.holon).toBe(testHolon);
+            expect(hologram.lens).toBeDefined(); // Could be testLens or otherLens
+            expect(hologram.key).toBeDefined();
+            expect(hologram.id).toBeDefined();
+            expect(hologram.timestamp).toBeDefined();
+            expect(typeof hologram.timestamp).toBe('number');
+        });
+        
+        // Verify that the souls match what we expect
+        const expectedSouls = [
+            `${appName}/${testHolon}/${otherLens}/hologram-1`,
+            `${appName}/${testHolon}/${otherLens}/hologram-2`
+        ];
+        
+        const returnedSouls = result.updatedHolograms.map(h => h.soul);
+        expectedSouls.forEach(expectedSoul => {
+            expect(returnedSouls).toContain(expectedSoul);
+        });
+    });
+
+    test('put should return updated holograms with correct structure', async () => {
+        const originalData = { id: 'structure-test', value: 'Test Value' };
+        
+        // Put original data
+        await holoSphere.put(testHolon, testLens, originalData);
+        await waitForGun();
+        
+        // Create one hologram
+        const hologram = holoSphere.createHologram(testHolon, testLens, originalData);
+        await holoSphere.put(testHolon, otherLens, { id: 'structure-hologram', soul: hologram.soul });
+        await waitForGun(500);
+        
+        // Update original data
+        const updatedData = { ...originalData, value: 'Updated Test Value' };
+        const result = await holoSphere.put(testHolon, testLens, updatedData);
+        
+        expect(result.updatedHolograms).toHaveLength(1);
+        
+        const updatedHologram = result.updatedHolograms[0];
+        expect(updatedHologram).toEqual({
+            soul: `${appName}/${testHolon}/${otherLens}/structure-hologram`,
+            holon: testHolon,
+            lens: otherLens,
+            key: 'structure-hologram',
+            id: 'structure-hologram',
+            timestamp: expect.any(Number)
+        });
+        
+        // Verify timestamp is recent (within last few seconds)
+        const now = Date.now();
+        expect(updatedHologram.timestamp).toBeGreaterThan(now - 5000);
+        expect(updatedHologram.timestamp).toBeLessThanOrEqual(now);
+    });
+
+    test('put with isHologramUpdate option should not return updated holograms', async () => {
+        const originalData = { id: 'no-recursive-test', value: 'Original Value' };
+        
+        // Put original data
+        await holoSphere.put(testHolon, testLens, originalData);
+        await waitForGun();
+        
+        // Create hologram
+        const hologram = holoSphere.createHologram(testHolon, testLens, originalData);
+        await holoSphere.put(testHolon, otherLens, { id: 'recursive-test', soul: hologram.soul });
+        await waitForGun(500);
+        
+        // Update with isHologramUpdate flag (should not trigger hologram updates)
+        const updatedData = { ...originalData, value: 'Updated Value' };
+        const result = await holoSphere.put(testHolon, testLens, updatedData, null, { isHologramUpdate: true });
+        
+        expect(result).toBeDefined();
+        expect(result.success).toBe(true);
+        expect(result.updatedHolograms).toBeDefined();
+        expect(result.updatedHolograms).toHaveLength(0);
+    });
+
+    test('put hologram should not return updated holograms', async () => {
+        const originalData = { id: 'hologram-put-test', value: 'Original Value' };
+        
+        // Put original data
+        await holoSphere.put(testHolon, testLens, originalData);
+        await waitForGun();
+        
+        // Put a hologram (not original data)
+        const hologram = holoSphere.createHologram(testHolon, testLens, originalData);
+        const result = await holoSphere.put(testHolon, otherLens, { id: 'test-hologram', soul: hologram.soul });
+        
+        expect(result).toBeDefined();
+        expect(result.success).toBe(true);
+        expect(result.updatedHolograms).toBeDefined();
+        expect(result.updatedHolograms).toHaveLength(0);
+    });
+});