holosphere 1.1.9 → 1.1.11

package/node.js

@@ -0,0 +1,155 @@
+// 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;
+            // }
+            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 {
+                        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');
+    }
+    return new Promise((resolve, reject) => {
+        holoInstance.gun.get(holoInstance.appname)
+            .get(holon)
+            .get(lens)
+            .get(key)
+            .put(null, ack => {
+                if (ack.err) {
+                    reject(new Error(ack.err));
+                } else {
+                    resolve(true);
+                }
+            });
+    });
+} 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "holosphere",
-  "version": "1.1.9",
+  "version": "1.1.11",
   "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

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