holosphere 1.1.10 → 1.1.12

package/node.js

@@ -0,0 +1,240 @@
+// holo_node.js
+
+/**
+ * Stores a specific gun node in a given holon and lens.
+ * @param {HoloSphere} holoInstance - The HoloSphere instance.
+ * @param {string} holon - The holon identifier.
+ * @param {string} lens - The lens under which to store the node.
+ * @param {object} data - The node to store.
+ */
+export async function putNode(holoInstance, holon, lens, data) {
+    if (!holon || !lens || !data) {
+        throw new Error('putNode: Missing required parameters');
+    }
+
+    return new Promise((resolve, reject) => {
+        try {
+            // Remove isHologram field before storing - NO LONGER NEEDED
+            // 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)
+                .get('value')  // Store at 'value' key
+                .put(data.value, ack => {  // Store the value directly
+                    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);
+                    }
+                });
+        } catch (error) {
+            reject(error);
+        }
+    });
+}
+
+/**
+ * Retrieves a specific gun node from the specified holon and lens.
+ * @param {HoloSphere} holoInstance - The HoloSphere instance.
+ * @param {string} holon - The holon identifier.
+ * @param {string} lens - The lens identifier.
+ * @param {string} key - The specific key to retrieve.
+ * @returns {Promise<any>} - The retrieved node or null if not found.
+ */
+export async function getNode(holoInstance, holon, lens, key) {
+    if (!holon || !lens || !key) {
+        throw new Error('getNode: Missing required parameters');
+    }
+
+    return new Promise((resolve, reject) => {
+        try {
+            holoInstance.gun.get(holoInstance.appname)
+                .get(holon)
+                .get(lens)
+                .get(key)
+                .once((data) => {
+                    if (!data) {
+                        resolve(null);
+                        return;
+                    }
+                    resolve(data);  // Return the data directly
+                });
+        } catch (error) {
+            reject(error);
+        }
+    });
+}
+
+/**
+ * Retrieves a Gun node reference using its soul path
+ * @param {HoloSphere} holoInstance - The HoloSphere instance.
+ * @param {string} soul - The soul path of the node
+ * @returns {Gun.ChainReference} - The Gun node reference
+ */
+export function getNodeRef(holoInstance, soul) {
+    if (typeof soul !== 'string' || !soul) {
+        throw new Error('getNodeRef: Invalid soul parameter');
+    }
+
+    const parts = soul.split('/').filter(part => {
+        if (!part.trim() || /[<>:"/\\|?*]/.test(part)) { // Escaped backslash for regex
+            throw new Error('getNodeRef: Invalid path segment');
+        }
+        return part.trim();
+    });
+
+    if (parts.length === 0) {
+        throw new Error('getNodeRef: Invalid soul format');
+    }
+
+    let ref = holoInstance.gun.get(holoInstance.appname);
+    parts.forEach(part => {
+        ref = ref.get(part);
+    });
+    return ref;
+}
+
+/**
+ * Retrieves a node directly using its soul path
+ * @param {HoloSphere} holoInstance - The HoloSphere instance.
+ * @param {string} soul - The soul path of the node
+ * @returns {Promise<any>} - The retrieved node or null if not found.
+ */
+export async function getNodeBySoul(holoInstance, soul) {
+    if (!soul) {
+        throw new Error('getNodeBySoul: Missing soul parameter');
+    }
+
+    console.log(`getNodeBySoul: Accessing soul ${soul}`);
+
+    return new Promise((resolve, reject) => {
+        try {
+            const ref = getNodeRef(holoInstance, soul); // Use the exported getNodeRef
+            ref.once((data) => {
+                console.log(`getNodeBySoul: Retrieved data:`, data);
+                if (!data) {
+                    resolve(null);
+                    return;
+                }
+                resolve(data);  // Return the data directly
+            });
+        } catch (error) {
+            console.error(`getNodeBySoul error:`, error);
+            reject(error);
+        }
+    });
+}
+
+/**
+ * Deletes a specific gun node from a given holon and lens.
+ * @param {HoloSphere} holoInstance - The HoloSphere instance.
+ * @param {string} holon - The holon identifier.
+ * @param {string} lens - The lens identifier.
+ * @param {string} key - The key of the node to delete.
+ * @returns {Promise<boolean>} - Returns true if successful
+ */
+export async function deleteNode(holoInstance, holon, lens, key) {
+    if (!holon || !lens || !key) {
+        throw new Error('deleteNode: Missing required parameters');
+    }
+
+    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.10",
+  "version": "1.1.12",
   "description": "Holonic Geospatial Communication Infrastructure",
   "main": "holosphere.js",
   "types": "holosphere.d.ts",
@@ -24,9 +24,6 @@
   },
   "jest": {
     "testEnvironment": "node",
-    "transform": {},
-    "moduleNameMapper": {
-      "^(\\.{1,2}/.*)\\.js$": "$1"
-    }
+    "transform": {}
   }
 }

package/schema.js

@@ -0,0 +1,132 @@
+// holo_schema.js
+
+import Ajv2019 from 'ajv/dist/2019.js';
+
+/**
+ * Sets the JSON schema for a specific lens.
+ * @param {HoloSphere} holoInstance - The HoloSphere instance.
+ * @param {string} lens - The lens identifier.
+ * @param {object} schema - The JSON schema to set.
+ * @returns {Promise<boolean>} - Resolves when the schema is set.
+ */
+export async function setSchema(holoInstance, lens, schema) {
+    if (!lens || !schema) {
+        throw new Error('setSchema: Missing required parameters');
+    }
+
+    // Basic schema validation
+    if (!schema.type || typeof schema.type !== 'string') {
+        throw new Error('setSchema: Schema must have a type field');
+    }
+
+    const metaSchema = {
+        type: 'object',
+        required: ['type', 'properties'],
+        properties: {
+            type: { type: 'string' },
+            properties: {
+                type: 'object',
+                additionalProperties: {
+                    type: 'object',
+                    required: ['type'],
+                    properties: {
+                        type: { type: 'string' }
+                    }
+                }
+            },
+            required: {
+                type: 'array',
+                items: { type: 'string' }
+            }
+        }
+    };
+
+    // Use the validator from the instance
+    const valid = holoInstance.validator.validate(metaSchema, schema);
+    if (!valid) {
+        throw new Error(`Invalid schema structure: ${JSON.stringify(holoInstance.validator.errors)}`);
+    }
+
+    if (!schema.properties || typeof schema.properties !== 'object') {
+        throw new Error('Schema must have properties in strict mode');
+    }
+
+    if (!schema.required || !Array.isArray(schema.required) || schema.required.length === 0) {
+        throw new Error('Schema must have required fields in strict mode');
+    }
+
+    // Store schema in global table with lens as key using instance's method
+    await holoInstance.putGlobal('schemas', {
+        id: lens,
+        schema: schema,
+        timestamp: Date.now()
+    });
+
+    // Update the instance's cache with the new schema
+    holoInstance.schemaCache.set(lens, {
+        schema,
+        timestamp: Date.now()
+    });
+
+    return true;
+}
+
+/**
+ * Retrieves the JSON schema for a specific lens.
+ * @param {HoloSphere} holoInstance - The HoloSphere instance.
+ * @param {string} lens - The lens identifier.
+ * @param {object} [options] - Additional options
+ * @param {boolean} [options.useCache=true] - Whether to use the schema cache
+ * @param {number} [options.maxCacheAge=3600000] - Maximum cache age in milliseconds (default: 1 hour)
+ * @returns {Promise<object|null>} - The retrieved schema or null if not found.
+ */
+export async function getSchema(holoInstance, lens, options = {}) {
+    if (!lens) {
+        throw new Error('getSchema: Missing lens parameter');
+    }
+
+    const { useCache = true, maxCacheAge = 3600000 } = options;
+
+    // Check instance's cache first if enabled
+    if (useCache && holoInstance.schemaCache.has(lens)) {
+        const cached = holoInstance.schemaCache.get(lens);
+        const cacheAge = Date.now() - cached.timestamp;
+
+        // Use cache if it's fresh enough
+        if (cacheAge < maxCacheAge) {
+            return cached.schema;
+        }
+    }
+
+    // Cache miss or expired, fetch from storage using instance's method
+    const schemaData = await holoInstance.getGlobal('schemas', lens);
+
+    if (!schemaData || !schemaData.schema) {
+        return null;
+    }
+
+    // Update instance's cache with fetched schema
+    holoInstance.schemaCache.set(lens, {
+        schema: schemaData.schema,
+        timestamp: Date.now()
+    });
+
+    return schemaData.schema;
+}
+
+/**
+ * Clears the schema cache or a specific schema from the cache.
+ * @param {HoloSphere} holoInstance - The HoloSphere instance.
+ * @param {string} [lens] - Optional lens to clear from cache. If not provided, clears entire cache.
+ * @returns {boolean} - Returns true if successful
+ */
+export function clearSchemaCache(holoInstance, lens = null) {
+    if (lens) {
+        // Clear specific schema from instance's cache
+        return holoInstance.schemaCache.delete(lens);
+    } else {
+        // Clear entire instance's cache
+        holoInstance.schemaCache.clear();
+        return true;
+    }
+} 

package/test/auth.test.js

@@ -10,6 +10,8 @@ describe('HoloSphere Authentication and Authorization', () => {
     const testPassword = 'TestPass123!';
     const testHolon = 'test-holon';
     const testLens = 'test-lens';
+    const PUBLIC_GLOBAL_TABLE = 'publicTestTable'; // For public global data
+    const PRIVATE_GLOBAL_TABLE = 'veryPrivateGlobalTable'; // For all private global data tests
 
     beforeAll(async () => {
         holoSphere = new HoloSphere('test-app', false, null);
@@ -21,6 +23,8 @@ describe('HoloSphere Authentication and Authorization', () => {
     beforeEach(async () => {
         // Clean state before each test
         await holoSphere.deleteAll(testHolon, testLens);
+        await holoSphere.deleteAllGlobal(PUBLIC_GLOBAL_TABLE);
+        await holoSphere.deleteAllGlobal(PRIVATE_GLOBAL_TABLE, testPassword);
         await new Promise(resolve => setTimeout(resolve, 100));
     });
 
@@ -40,19 +44,41 @@ describe('HoloSphere Authentication and Authorization', () => {
 
     afterAll(async () => {
         // Clean up all test data
-        await holoSphere.deleteAll(testHolon, testLens);
-        await holoSphere.deleteAllGlobal('testTable');
-        
-        // Close HoloSphere instances
-        if (holoSphere) {
-            await holoSphere.close();
+        try {
+            if (holoSphere) {
+                await holoSphere.deleteAll(testHolon, testLens);
+                await holoSphere.deleteAllGlobal(PUBLIC_GLOBAL_TABLE);
+                await holoSphere.deleteAllGlobal(PRIVATE_GLOBAL_TABLE, testPassword);
+            }
+            if (strictHoloSphere) {
+                 await strictHoloSphere.deleteAll(testHolon, testLens);
+                await strictHoloSphere.deleteAllGlobal(PUBLIC_GLOBAL_TABLE);
+                await strictHoloSphere.deleteAllGlobal(PRIVATE_GLOBAL_TABLE, testPassword);
+            }
+        } catch (error) {
+            console.error('Error during afterAll data cleanup:', error);
         }
-        if (strictHoloSphere) {
-            await strictHoloSphere.close();
+
+        // Close HoloSphere instances
+        try {
+            if (holoSphere) {
+                console.log('Closing non-strict HoloSphere instance...');
+                await holoSphere.close();
+                console.log('Non-strict HoloSphere instance closed.');
+            }
+            if (strictHoloSphere) {
+                console.log('Closing strict HoloSphere instance...');
+                await strictHoloSphere.close();
+                console.log('Strict HoloSphere instance closed.');
+            }
+        } catch (error) {
+             console.error('Error during afterAll close:', error);
         }
-        
-        // Wait for connections to close
-        await new Promise(resolve => setTimeout(resolve, 1000));
+
+        // Add a slightly longer, more explicit wait after close calls
+        console.log('Waiting extra time for cleanup...');
+        await new Promise(resolve => setTimeout(resolve, 2000)); 
+        console.log('Finished afterAll.');
     });
 
     describe('Authentication System', () => {
@@ -81,6 +107,7 @@ describe('HoloSphere Authentication and Authorization', () => {
             const testData = { id: 'test2', value: 'private-data' };
             
             // Store data with correct password
+            await new Promise(resolve => setTimeout(resolve, 100)); // Added delay
             await holoSphere.put(testHolon, testLens, testData, testPassword);
             
             // Try to retrieve with wrong password
@@ -202,41 +229,35 @@ describe('HoloSphere Authentication and Authorization', () => {
 
     describe('Global Data Operations', () => {
         it('should handle private global data', async () => {
-            const testData = { id: 'global', value: 111 };
-            
-            await holoSphere.putGlobal('testTable', testData, testPassword);
-            
-            const result = await holoSphere.getGlobal('testTable', testData.id, testPassword);
+            const testData = { id: 'globalPrivateItem', value: 111 };
+            await holoSphere.putGlobal(PRIVATE_GLOBAL_TABLE, testData, testPassword);
+            const result = await holoSphere.getGlobal(PRIVATE_GLOBAL_TABLE, testData.id, testPassword);
             expect(result).toEqual(testData);
         });
 
         it('should handle public global data', async () => {
-            const testData = { id: 'public_global', value: 222 };
-            
-            await holoSphere.putGlobal('testTable', testData);
-            
-            const result = await holoSphere.getGlobal('testTable', testData.id);
+            const testData = { id: 'publicGlobalItem', value: 222 };
+            await holoSphere.putGlobal(PUBLIC_GLOBAL_TABLE, testData);
+            const result = await holoSphere.getGlobal(PUBLIC_GLOBAL_TABLE, testData.id);
             expect(result).toEqual(testData);
         });
 
         it('should handle getAllGlobal with private data', async () => {
             const testData = [
-                { id: 'global1', value: 1 },
-                { id: 'global2', value: 2 }
+                { id: 'globalPrivate1', value: 1 },
+                { id: 'globalPrivate2', value: 2 }
             ];
             
-            // Clean up any existing data first
-            await holoSphere.deleteAllGlobal('testTable', testPassword);
+            // Clean up before this specific test (already done in beforeEach, but good for clarity)
+            // await holoSphere.deleteAllGlobal(PRIVATE_GLOBAL_TABLE, testPassword); // This might be re-enabled later if tests pass without it
             
-            // Store each item
             for (const data of testData) {
-                await holoSphere.putGlobal('testTable', data, testPassword);
+                await holoSphere.putGlobal(PRIVATE_GLOBAL_TABLE, data, testPassword);
             }
             
-            // Wait a bit for data to settle
-            await new Promise(resolve => setTimeout(resolve, 1000));
+            await new Promise(resolve => setTimeout(resolve, 1000)); // Settle time
             
-            const results = await holoSphere.getAllGlobal('testTable', testPassword);
+            const results = await holoSphere.getAllGlobal(PRIVATE_GLOBAL_TABLE, testPassword);
             expect(results.length).toBe(testData.length);
             for (const data of testData) {
                 expect(results).toContainEqual(expect.objectContaining(data));
@@ -244,13 +265,10 @@ describe('HoloSphere Authentication and Authorization', () => {
         }, 10000);
 
         it('should handle deleteGlobal with private data', async () => {
-            const testData = { id: 'delete_global', value: 333 };
-            
-            await holoSphere.putGlobal('testTable', testData, testPassword);
-            
-            await holoSphere.deleteGlobal('testTable', testData.id, testPassword);
-            
-            const result = await holoSphere.getGlobal('testTable', testData.id, testPassword);
+            const testData = { id: 'deleteGlobalPrivate', value: 333 };
+            await holoSphere.putGlobal(PRIVATE_GLOBAL_TABLE, testData, testPassword);
+            await holoSphere.deleteGlobal(PRIVATE_GLOBAL_TABLE, testData.id, testPassword);
+            const result = await holoSphere.getGlobal(PRIVATE_GLOBAL_TABLE, testData.id, testPassword);
             expect(result).toBeNull();
         });
     });

package/test/delete.test.js

@@ -4,6 +4,9 @@ import { jest } from '@jest/globals';
 // Configure Jest
 jest.setTimeout(30000); // 30 second timeout
 
+// Utility to wait for GunDB propagation
+const waitForGun = (delay = 250) => new Promise(resolve => setTimeout(resolve, delay));
+
 describe('HoloSphere Deletion Tests', () => {
     const testAppName = 'test-app-deletion';
     const testHolon = 'testHolonDeletion';
@@ -106,21 +109,21 @@ describe('HoloSphere Deletion Tests', () => {
         test('should delete global items properly', async () => {
             // Create global test data
             const globalData = { id: 'global-delete-test', value: 'global delete me' };
-            
-            // Store global data
+
+            // 1. Store global data
             await holoSphere.putGlobal(testGlobalTable, globalData);
-            
-            // 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
+
+            // 2. Wait significantly for put to settle
+            await waitForGun(1500); // Generous wait after put
+
+            // 3. Delete global data
             const deleteResult = await holoSphere.deleteGlobal(testGlobalTable, globalData.id);
             expect(deleteResult).toBe(true);
-            
-            // Verify global data is deleted
+
+            // 4. Wait for delete to settle
+            await waitForGun(500); // Wait after delete
+
+            // 5. Verify global data is deleted
             const deletedGlobalData = await holoSphere.getGlobal(testGlobalTable, globalData.id);
             expect(deletedGlobalData).toBeNull();
         });