holosphere 1.1.10 → 1.1.11

package/test/subscription.test.js

@@ -6,22 +6,39 @@ jest.setTimeout(30000);
 
 describe('Subscription Tests', () => {
   let holosphere;
-  const testHolon = `test_subscription_${Date.now()}`;
+  let testAppName; // Make app name dynamic
+  const testHolonBase = 'test_subscription_holon';
   const testLens = 'items';
+  let testHolon; // Make holon dynamic
   
-  beforeEach(() => {
-    // Create a fresh HoloSphere instance for each test
-    holosphere = new HoloSphere('testApp', false);
+  beforeEach(async () => {
+    // Create a fresh HoloSphere instance with unique names for each test
+    testAppName = `testApp_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+    testHolon = `${testHolonBase}_${Date.now()}`;
+    holosphere = new HoloSphere(testAppName, false);
+    // Add a small delay after initialization
+    await new Promise(resolve => setTimeout(resolve, 100));
   });
   
   afterEach(async () => {
-    // Clean up resources
+    // Clean up resources and potentially test data
     try {
-      await holosphere.close();
+      if (holosphere) {
+        // Attempt to delete data created in the test holon/lenses
+        try {
+           await holosphere.deleteAll(testHolon, testLens);
+           await holosphere.deleteAll(testHolon, 'differentLens');
+           // Wait a bit for deletes to process
+           await new Promise(resolve => setTimeout(resolve, 200));
+        } catch (deleteError) {
+            console.warn(`Error during test cleanup deleteAll:`, deleteError);
+        }
+        await holosphere.close();
+      }
     } catch (error) {
-      console.warn('Error closing HoloSphere:', error);
+      console.warn('Error during afterEach cleanup:', error);
     }
-    jest.clearAllMocks();
+    // jest.clearAllMocks(); // Not needed if not using jest.fn()
   });
   
   test('should properly clean up subscription when unsubscribing', async () => {
@@ -32,7 +49,7 @@ describe('Subscription Tests', () => {
     };
     
     // Create a mock callback function
-  function mockCallback (data) {
+    function mockCallback (data) {
       console.log('Callback received:', data);
     }
     
@@ -47,11 +64,10 @@ describe('Subscription Tests', () => {
     
     // Verify the subscription object has the expected structure
     expect(holosphere.subscriptions[subscriptionId]).toBeDefined();
-    expect(holosphere.subscriptions[subscriptionId].active).toBe(true);
     expect(holosphere.subscriptions[subscriptionId].holon).toBe(testHolon);
     expect(holosphere.subscriptions[subscriptionId].lens).toBe(testLens);
     expect(holosphere.subscriptions[subscriptionId].callback).toBe(mockCallback);
-    expect(holosphere.subscriptions[subscriptionId].gunSubscription).toBeDefined();
+    expect(holosphere.subscriptions[subscriptionId].mapChain).toBeDefined();
     
     // Now unsubscribe
     await subscription.unsubscribe();
@@ -64,104 +80,123 @@ describe('Subscription Tests', () => {
   test('should not receive updates after unsubscribing', async () => {
     // Create test data
     const testData = {
-      id: 'test-item',
-      value: 'Test value'
+      id: 'test-item-unsub',
+      value: 'Initial value for unsub test'
     };
-    
-    // Create a mock callback function
-    const mockCallback = jest.fn((data) => {
-      console.log('Callback received:', data);
-    });
-    
+
+    // Use a flag to track callback execution
+    let callbackFired = false;
+    let receivedData = null;
+    const dataCallback = (data) => {
+      console.log('Callback received (unsub test):', data);
+      callbackFired = true;
+      receivedData = data;
+    };
+
     // Set up subscription
-    const subscription = await holosphere.subscribe(testHolon, testLens, mockCallback);
-    
+    const subscription = await holosphere.subscribe(testHolon, testLens, dataCallback);
+
     // Store data to trigger subscription
     await holosphere.put(testHolon, testLens, testData);
-    
+
     // Wait a bit for the subscription to trigger
     await new Promise(resolve => setTimeout(resolve, 1000));
-    
+
     // Verify callback was called
-    expect(mockCallback).toHaveBeenCalled();
-    
-    // Reset the mock
-    mockCallback.mockClear();
-    
+    expect(callbackFired).toBe(true);
+    expect(receivedData).toEqual(expect.objectContaining(testData));
+
+    // Reset the flag
+    callbackFired = false;
+    receivedData = null;
+
     // Unsubscribe
     await subscription.unsubscribe();
-    
+
     // Store more data
-    const newData = { ...testData, value: 'Updated value' };
+    const newData = { ...testData, value: 'Updated value after unsub' };
     await holosphere.put(testHolon, testLens, newData);
-    
+
     // Wait a bit to ensure no callbacks are triggered
     await new Promise(resolve => setTimeout(resolve, 1000));
-    
+
     // Verify callback was NOT called after unsubscribing
-    expect(mockCallback).not.toHaveBeenCalled();
+    expect(callbackFired).toBe(false);
+    expect(receivedData).toBeNull();
   });
   
   test('should handle multiple subscriptions and unsubscriptions correctly', async () => {
-    // Create mock callbacks
-    const mockCallback1 = jest.fn((data) => {
-      console.log('Callback 1 received:', data);
-    });
-    const mockCallback2 = jest.fn((data) => {
-      console.log('Callback 2 received:', data);
-    });
-    const mockCallback3 = jest.fn((data) => {
-      console.log('Callback 3 received:', data);
-    });
-    
+    // Use flags to track callback execution
+    let callback1Fired = false;
+    let callback2Fired = false;
+    let callback3Fired = false;
+    let dataForCb1 = null;
+
+    const cb1 = (data) => {
+      console.log('Callback 1 received (multi test):', data);
+      callback1Fired = true;
+      dataForCb1 = data;
+    };
+    const cb2 = (data) => {
+      console.log('Callback 2 received (multi test):', data);
+      callback2Fired = true;
+    };
+    const cb3 = (data) => {
+      console.log('Callback 3 received (multi test):', data);
+      callback3Fired = true;
+    };
+
     // Set up multiple subscriptions
-    const subscription1 = await holosphere.subscribe(testHolon, testLens, mockCallback1);
-    const subscription2 = await holosphere.subscribe(testHolon, testLens, mockCallback2);
-    const subscription3 = await holosphere.subscribe(testHolon, 'differentLens', mockCallback3);
-    
+    const subscription1 = await holosphere.subscribe(testHolon, testLens, cb1);
+    const subscription2 = await holosphere.subscribe(testHolon, testLens, cb2);
+    const subscription3 = await holosphere.subscribe(testHolon, 'differentLens', cb3);
+
     // Verify subscriptions were created
     expect(Object.keys(holosphere.subscriptions).length).toBe(3);
-    
-    // Unsubscribe from one subscription
+
+    // Unsubscribe from one subscription (subscription2)
     await subscription2.unsubscribe();
-    
+
     // Verify only the correct subscription was removed
     expect(Object.keys(holosphere.subscriptions).length).toBe(2);
-    
+
     // Create test data
     const testData = {
-      id: 'test-item',
-      value: 'Test value'
+      id: 'test-item-multi',
+      value: 'Test value for multi sub'
     };
-    
+
     // Store data to trigger remaining subscriptions
     await holosphere.put(testHolon, testLens, testData);
-    
+
     // Wait a bit for the subscription to trigger
     await new Promise(resolve => setTimeout(resolve, 1000));
-    
+
     // Verify only active callbacks were called
-    expect(mockCallback1).toHaveBeenCalled();
-    expect(mockCallback2).not.toHaveBeenCalled();
-    expect(mockCallback3).not.toHaveBeenCalled(); // Different lens
-    
+    expect(callback1Fired).toBe(true);
+    expect(dataForCb1).toEqual(expect.objectContaining(testData));
+    expect(callback2Fired).toBe(false); // This callback should not have fired
+    expect(callback3Fired).toBe(false); // Different lens
+
     // Unsubscribe from all remaining subscriptions
     await subscription1.unsubscribe();
     await subscription3.unsubscribe();
-    
+
     // Verify all subscriptions were removed
     expect(Object.keys(holosphere.subscriptions).length).toBe(0);
   });
   
   test('should clean up subscriptions when closing HoloSphere instance', async () => {
-    // Create mock callback
-    const mockCallback = jest.fn((data) => {
-      console.log('Callback received:', data);
-    });
-    
+    // Use a flag - not strictly needed for assertion but good practice
+    let callbackFired = false;
+    const dataCallback = (data) => {
+      console.log('Callback received (close test):', data);
+      callbackFired = true;
+    };
+
     // Set up subscription
-    await holosphere.subscribe(testHolon, testLens, mockCallback);
-    
+    await holosphere.subscribe(testHolon, testLens, dataCallback);
+
     // Verify subscription was created
     expect(Object.keys(holosphere.subscriptions).length).toBe(1);
     
@@ -303,7 +338,7 @@ describe('Subscription Tests', () => {
     }
     
     // Try to resolve the reference to verify it works correctly
-    const resolvedData = await holosphere.get(referenceHolon, testLens, originalData.id, null, { resolveReferences: true });
+    const resolvedData = await holosphere.get(referenceHolon, testLens, originalData.id, null, { resolveHolograms: true });
     console.log('Resolved data:', resolvedData);
     
     // The resolved data should not be null

package/utils.js

@@ -0,0 +1,290 @@
+// holo_utils.js
+import * as h3 from 'h3-js';
+
+/**
+ * Converts latitude and longitude to a holon identifier.
+ * @param {number} lat - The latitude.
+ * @param {number} lng - The longitude.
+ * @param {number} resolution - The resolution level.
+ * @returns {Promise<string>} - The resulting holon identifier.
+ */
+export async function getHolon(lat, lng, resolution) { // Doesn't need holoInstance
+    return h3.latLngToCell(lat, lng, resolution);
+}
+
+/**
+ * Retrieves all containing holonagons at all scales for given coordinates.
+ * @param {number} lat - The latitude.
+ * @param {number} lng - The longitude.
+ * @returns {Array<string>} - List of holon identifiers.
+ */
+export function getScalespace(lat, lng) { // Doesn't need holoInstance
+    let list = []
+    let cell = h3.latLngToCell(lat, lng, 14);
+    list.push(cell)
+    for (let i = 13; i >= 0; i--) {
+        list.push(h3.cellToParent(cell, i))
+    }
+    return list
+}
+
+/**
+ * Retrieves all containing holonagons at all scales for a given holon.
+ * @param {string} holon - The holon identifier.
+ * @returns {Array<string>} - List of holon identifiers.
+ */
+export function getHolonScalespace(holon) { // Doesn't need holoInstance
+    let list = []
+    let res = h3.getResolution(holon)
+    for (let i = res; i >= 0; i--) {
+        list.push(h3.cellToParent(holon, i))
+    }
+    return list
+}
+
+/**
+ * Subscribes to changes in a specific holon and lens.
+ * @param {HoloSphere} holoInstance - The HoloSphere instance.
+ * @param {string} holon - The holon identifier.
+ * @param {string} lens - The lens to subscribe to.
+ * @param {function} callback - The callback to execute on changes.
+ * @returns {Promise<object>} - Subscription object with unsubscribe method
+ */
+export async function subscribe(holoInstance, holon, lens, callback) {
+    if (!holon || !lens) {
+        throw new Error('subscribe: Missing holon or lens parameters:', holon, lens);
+    }
+
+    if (!callback || typeof callback !== 'function') {
+        throw new Error('subscribe: Callback must be a function');
+    }
+
+    const subscriptionId = holoInstance.generateId(); // Use instance's generateId
+
+    try {
+        // Get the Gun chain up to the map()
+        const mapChain = holoInstance.gun.get(holoInstance.appname).get(holon).get(lens).map();
+
+        // Create the subscription by calling .on() on the map chain
+        const gunListener = mapChain.on(async (data, key) => { // Renamed variable
+            // Check if subscription ID still exists (might have been unsubscribed)
+            if (!holoInstance.subscriptions[subscriptionId]) {
+                return;
+            }
+
+            if (data) {
+                try {
+                    let parsed = await holoInstance.parse(data);
+                    if (parsed && holoInstance.isHologram(parsed)) {
+                        const resolved = await holoInstance.resolveHologram(parsed, { followHolograms: true });
+                        if (resolved !== parsed) {
+                            parsed = resolved;
+                        }
+                    }
+
+                    // Check again if subscription ID still exists before calling callback
+                    if (holoInstance.subscriptions[subscriptionId]) {
+                        callback(parsed, key);
+                    }
+                } catch (error) {
+                    console.error('Error processing subscribed data:', error);
+                }
+            }
+        });
+
+        // Store the subscription with its ID on the instance
+        holoInstance.subscriptions[subscriptionId] = {
+            id: subscriptionId,
+            holon,
+            lens,
+            callback,
+            mapChain: mapChain,       // Store the map chain
+            gunListener: gunListener  // Store the listener too (optional, maybe needed for close?)
+        };
+
+        // Return an object with unsubscribe method
+        return {
+            unsubscribe: async () => {
+                const sub = holoInstance.subscriptions[subscriptionId];
+                if (!sub) {
+                    return;
+                }
+
+                try {
+                    // Turn off the Gun subscription using the stored mapChain reference
+                    if (sub.mapChain) { // Check if mapChain exists
+                        sub.mapChain.off(); // Call off() on the chain where .on() was attached
+                        // Optional: Add delay back? Let's omit for now.
+                        // await new Promise(res => setTimeout(res, 50));
+                    } // We might not need to call off() on gunListener explicitly
+
+                    // Remove from subscriptions object AFTER turning off listener
+                    delete holoInstance.subscriptions[subscriptionId];
+                } catch (error) {
+                    console.error(`Error during unsubscribe logic for ${subscriptionId}:`, error);
+                }
+            }
+        };
+    } catch (error) {
+        console.error('Error creating subscription:', error);
+        throw error;
+    }
+}
+
+/**
+ * Notifies subscribers about data changes
+ * @param {HoloSphere} holoInstance - The HoloSphere instance.
+ * @param {object} data - The data to notify about
+ * @private
+ */
+export function notifySubscribers(holoInstance, data) {
+    if (!data || !data.holon || !data.lens) {
+        return;
+    }
+
+    try {
+        Object.values(holoInstance.subscriptions).forEach(subscription => {
+            if (subscription.holon === data.holon &&
+                subscription.lens === data.lens) {
+                try {
+                    if (subscription.callback && typeof subscription.callback === 'function') {
+                        subscription.callback(data);
+                    }
+                } catch (error) {
+                    console.warn('Error in subscription callback:', error);
+                }
+            }
+        });
+    } catch (error) {
+        console.warn('Error notifying subscribers:', error);
+    }
+}
+
+// Add ID generation method
+export function generateId() { // Doesn't need holoInstance
+    return Date.now().toString(10) + Math.random().toString(2);
+}
+
+/**
+ * Closes the HoloSphere instance and cleans up resources.
+ * @param {HoloSphere} holoInstance - The HoloSphere instance.
+ * @returns {Promise<void>}
+ */
+export async function close(holoInstance) {
+    try {
+        if (holoInstance.gun) {
+            // Unsubscribe from all subscriptions
+            const subscriptionIds = Object.keys(holoInstance.subscriptions);
+            for (const id of subscriptionIds) {
+                try {
+                    const subscription = holoInstance.subscriptions[id];
+                    if (subscription) {
+                        // Turn off the Gun subscription using the stored mapChain reference
+                        if (subscription.mapChain) {
+                            subscription.mapChain.off();
+                        } // Also turn off listener directly? Might be redundant.
+                        // if (subscription.gunListener) {
+                        //     subscription.gunListener.off();
+                        // }
+                    }
+                } catch (error) {
+                    console.warn(`Error cleaning up subscription ${id}:`, error);
+                }
+            }
+
+            // Clear subscriptions
+            holoInstance.subscriptions = {};
+
+            // Clear schema cache using instance method
+            holoInstance.clearSchemaCache();
+
+            // Close Gun connections
+            if (holoInstance.gun.back) {
+                try {
+                    // Clean up mesh connections
+                    const mesh = holoInstance.gun.back('opt.mesh');
+                    if (mesh) {
+                        // Clean up mesh.hear
+                        if (mesh.hear) {
+                            try {
+                                // Safely clear mesh.hear without modifying function properties
+                                const hearKeys = Object.keys(mesh.hear);
+                                for (const key of hearKeys) {
+                                    // Check if it's an array before trying to clear it
+                                    if (Array.isArray(mesh.hear[key])) {
+                                        mesh.hear[key] = [];
+                                    }
+                                }
+
+                                // Create a new empty object for mesh.hear
+                                // Only if mesh.hear is not a function
+                                if (typeof mesh.hear !== 'function') {
+                                    mesh.hear = {};
+                                }
+                            } catch (meshError) {
+                                console.warn('Error cleaning up Gun mesh hear:', meshError);
+                            }
+                        }
+
+                        // Close any open sockets in the mesh
+                        if (mesh.way) {
+                            try {
+                                Object.values(mesh.way).forEach(connection => {
+                                    if (connection && connection.wire && connection.wire.close) {
+                                        connection.wire.close();
+                                    }
+                                });
+                            } catch (sockError) {
+                                console.warn('Error closing mesh sockets:', sockError);
+                            }
+                        }
+
+                        // Clear the peers list
+                        if (mesh.opt && mesh.opt.peers) {
+                            mesh.opt.peers = {};
+                        }
+                    }
+
+                    // Attempt to clean up any TCP connections
+                    if (holoInstance.gun.back('opt.web')) {
+                        try {
+                            const server = holoInstance.gun.back('opt.web');
+                            if (server && server.close) {
+                                server.close();
+                            }
+                        } catch (webError) {
+                            console.warn('Error closing web server:', webError);
+                        }
+                    }
+                } catch (error) {
+                    console.warn('Error accessing Gun mesh:', error);
+                }
+            }
+
+            // Clear all Gun instance listeners
+            try {
+                holoInstance.gun.off();
+            } catch (error) {
+                console.warn('Error turning off Gun listeners:', error);
+            }
+
+            // Wait a moment for cleanup to complete
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+
+        console.log('HoloSphere instance closed successfully');
+    } catch (error) {
+        console.error('Error closing HoloSphere instance:', error);
+    }
+}
+
+/**
+ * Creates a namespaced username for Gun authentication
+ * @param {HoloSphere} holoInstance - The HoloSphere instance.
+ * @param {string} holonId - The holon ID
+ * @returns {string} - Namespaced username
+ */
+export function userName(holoInstance, holonId) {
+    if (!holonId) return null;
+    return `${holoInstance.appname}:${holonId}`;
+}