holosphere 1.1.6 → 1.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "holosphere",
-  "version": "1.1.6",
+  "version": "1.1.8",
   "description": "Holonic Geospatial Communication Infrastructure",
   "main": "holosphere.js",
   "types": "holosphere.d.ts",
@@ -14,14 +14,11 @@
   "license": "GPL-3.0-or-later",
   "dependencies": {
     "ajv": "^8.12.0",
-    "axios": "^1.6.7",
-    "dotenv": "^16.4.7",
     "gun": "^0.2020.1240",
     "h3-js": "^4.1.0",
     "openai": "^4.85.1"
   },
   "devDependencies": {
-    "@babel/preset-env": "^7.24.0",
     "jest": "^29.7.0",
     "jest-environment-node": "^29.7.0"
   },

package/test/delete.test.js

@@ -0,0 +1,225 @@
+import HoloSphere from '../holosphere.js';
+import { jest } from '@jest/globals';
+
+// Configure Jest
+jest.setTimeout(30000); // 30 second timeout
+
+describe('HoloSphere Deletion Tests', () => {
+    const testAppName = 'test-app-deletion';
+    const testHolon = 'testHolonDeletion';
+    const testLens = 'testLensDeletion';
+    const testGlobalTable = 'testGlobalTable';
+    const testPassword = 'testPassword1234';
+    let holoSphere;
+
+    beforeAll(async () => {
+        holoSphere = new HoloSphere(testAppName, false, null);
+    });
+
+    afterAll(async () => {
+        // Clean up all test data
+        await holoSphere.deleteAll(testHolon, testLens);
+        await holoSphere.deleteAllGlobal(testGlobalTable);
+        
+        // Close Gun connections
+        if (holoSphere) {
+            await holoSphere.close();
+        }
+        
+        // Wait for connections to close
+        await new Promise(resolve => setTimeout(resolve, 1000));
+    });
+
+    describe('Basic Deletion', () => {
+        test('should delete a single item properly', async () => {
+            // Create test data
+            const testData = { id: 'delete-test-1', value: 'delete me' };
+            
+            // Store data
+            await holoSphere.put(testHolon, testLens, testData);
+            
+            // Verify data exists
+            const storedData = await holoSphere.get(testHolon, testLens, testData.id);
+            expect(storedData).toBeDefined();
+            expect(storedData.value).toBe(testData.value);
+            
+            // Delete data
+            const deleteResult = await holoSphere.delete(testHolon, testLens, testData.id);
+            expect(deleteResult).toBe(true);
+            
+            // Verify data is deleted
+            const deletedData = await holoSphere.get(testHolon, testLens, testData.id);
+            expect(deletedData).toBeNull();
+        });
+
+        test('should delete a node properly', async () => {
+            // Create test node data
+            const nodeData = { value: 'node-to-delete' };
+            const nodeKey = 'test-node-key';
+            
+            // Store node
+            await holoSphere.putNode(testHolon, testLens, { id: nodeKey, value: nodeData });
+            
+            // Verify node exists
+            const storedNode = await holoSphere.getNode(testHolon, testLens, 'value');
+            expect(storedNode).toBeDefined();
+            
+            // Delete node
+            const deleteResult = await holoSphere.deleteNode(testHolon, testLens, 'value');
+            expect(deleteResult).toBe(true);
+            
+            // Verify node is deleted
+            const deletedNode = await holoSphere.getNode(testHolon, testLens, 'value');
+            expect(deletedNode).toBeNull();
+        });
+    });
+
+    describe('Bulk Deletion', () => {
+        test('should delete all items in a lens', async () => {
+            // Create multiple test items
+            const items = [
+                { id: 'bulk-delete-1', value: 'bulk 1' },
+                { id: 'bulk-delete-2', value: 'bulk 2' },
+                { id: 'bulk-delete-3', value: 'bulk 3' }
+            ];
+            
+            // Store all items
+            for (const item of items) {
+                await holoSphere.put(testHolon, testLens, item);
+            }
+            
+            // Verify items exist
+            const allItems = await holoSphere.getAll(testHolon, testLens);
+            expect(allItems.length).toBeGreaterThanOrEqual(items.length);
+            
+            // Delete all items
+            const deleteAllResult = await holoSphere.deleteAll(testHolon, testLens);
+            expect(deleteAllResult).toBe(true);
+            
+            // Verify all items are deleted
+            const remainingItems = await holoSphere.getAll(testHolon, testLens);
+            expect(remainingItems.length).toBe(0);
+        });
+    });
+
+    describe('Global Table Deletion', () => {
+        test('should delete global items properly', async () => {
+            // Create global test data
+            const globalData = { id: 'global-delete-test', value: 'global delete me' };
+            
+            // 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
+            const deleteResult = await holoSphere.deleteGlobal(testGlobalTable, globalData.id);
+            expect(deleteResult).toBe(true);
+            
+            // Verify global data is deleted
+            const deletedGlobalData = await holoSphere.getGlobal(testGlobalTable, globalData.id);
+            expect(deletedGlobalData).toBeNull();
+        });
+
+        test('should delete all global items in a table', async () => {
+            // Create multiple global test items
+            const items = [
+                { id: 'global-bulk-1', value: 'global bulk 1' },
+                { id: 'global-bulk-2', value: 'global bulk 2' },
+                { id: 'global-bulk-3', value: 'global bulk 3' }
+            ];
+            
+            // Store all global items
+            for (const item of items) {
+                await holoSphere.putGlobal(testGlobalTable, item);
+            }
+            
+            // Verify global items exist
+            const allGlobalItems = await holoSphere.getAllGlobal(testGlobalTable);
+            expect(allGlobalItems.length).toBeGreaterThanOrEqual(items.length);
+            
+            // Delete all global items
+            const deleteAllResult = await holoSphere.deleteAllGlobal(testGlobalTable);
+            expect(deleteAllResult).toBe(true);
+            
+            // Verify all global items are deleted
+            const remainingGlobalItems = await holoSphere.getAllGlobal(testGlobalTable);
+            expect(remainingGlobalItems.length).toBe(0);
+        });
+    });
+
+    describe('Private Data Deletion', () => {
+        test('should delete private data properly', async () => {
+            // Create private test data
+            const privateData = { id: 'private-delete-test', value: 'private delete me' };
+            
+            // Store private data
+            await holoSphere.put(testHolon, testLens, privateData, testPassword);
+            
+            // Verify private data exists
+            const storedPrivateData = await holoSphere.get(testHolon, testLens, privateData.id, testPassword);
+            expect(storedPrivateData).toBeDefined();
+            expect(storedPrivateData.value).toBe(privateData.value);
+            
+            // Delete private data
+            const deleteResult = await holoSphere.delete(testHolon, testLens, privateData.id, testPassword);
+            expect(deleteResult).toBe(true);
+            
+            // Verify private data is deleted
+            const deletedPrivateData = await holoSphere.get(testHolon, testLens, privateData.id, testPassword);
+            expect(deletedPrivateData).toBeNull();
+        });
+
+        test('should delete all private items in a lens', async () => {
+            // Create multiple private test items
+            const items = [
+                { id: 'private-bulk-1', value: 'private bulk 1' },
+                { id: 'private-bulk-2', value: 'private bulk 2' },
+                { id: 'private-bulk-3', value: 'private bulk 3' }
+            ];
+            
+            // Store all private items
+            for (const item of items) {
+                await holoSphere.put(testHolon, testLens, item, testPassword);
+            }
+            
+            // Verify private items exist
+            const allPrivateItems = await holoSphere.getAll(testHolon, testLens, testPassword);
+            expect(allPrivateItems.length).toBeGreaterThanOrEqual(items.length);
+            
+            // Delete all private items
+            const deleteAllResult = await holoSphere.deleteAll(testHolon, testLens, testPassword);
+            expect(deleteAllResult).toBe(true);
+            
+            // Verify all private items are deleted
+            const remainingPrivateItems = await holoSphere.getAll(testHolon, testLens, testPassword);
+            expect(remainingPrivateItems.length).toBe(0);
+        });
+    });
+
+    describe('Edge Cases', () => {
+        test('should handle deletion of non-existent items gracefully', async () => {
+            // Try to delete non-existent item
+            const deleteResult = await holoSphere.delete(testHolon, testLens, 'non-existent-id');
+            expect(deleteResult).toBe(true); // Gun returns success even for non-existent items
+            
+            // Try to delete non-existent global item
+            const deleteGlobalResult = await holoSphere.deleteGlobal(testGlobalTable, 'non-existent-global-id');
+            expect(deleteGlobalResult).toBe(true);
+        });
+
+        test('should handle invalid parameters gracefully', async () => {
+            // Test with missing parameters
+            await expect(holoSphere.delete(null, testLens, 'test-id')).rejects.toThrow();
+            await expect(holoSphere.delete(testHolon, null, 'test-id')).rejects.toThrow();
+            await expect(holoSphere.delete(testHolon, testLens, null)).rejects.toThrow();
+            
+            // Test with missing global parameters
+            await expect(holoSphere.deleteGlobal(null, 'test-id')).rejects.toThrow();
+            await expect(holoSphere.deleteGlobal(testGlobalTable, null)).rejects.toThrow();
+        });
+    });
+}); 

package/test/federation.test.js

@@ -1,6 +1,9 @@
 import HoloSphere from '../holosphere.js';
 import { jest } from '@jest/globals';
 
+// Increase the default test timeout for all tests
+jest.setTimeout(30000);
+
 describe('Federation Tests', () => {
   let holosphere;
   const testPrefix = `test_${Date.now()}_`;
@@ -36,6 +39,50 @@ describe('Federation Tests', () => {
       }
     });
     
+    test('should set up the correct notification structure', async () => {
+      const space1 = `${testPrefix}notify_space1`;
+      const space2 = `${testPrefix}notify_space2`;
+      
+      // Create federation
+      await holosphere.federate(space1, space2, null, null);
+      
+      // Allow time for federation to be created
+      await new Promise(resolve => setTimeout(resolve, 1000));
+      
+      // In the current implementation:
+      // space1's federation list should contain space2
+      // space2's notify list should contain space1
+      const fedInfo1 = await holosphere.getGlobal('federation', space1);
+      expect(fedInfo1).toBeTruthy();
+      expect(fedInfo1.federation).toContain(space2);
+      
+      const fedInfo2 = await holosphere.getGlobal('federation', space2);
+      expect(fedInfo2).toBeTruthy();
+      expect(fedInfo2.notify).toContain(space1);
+    });
+    
+    test('should respect unidirectional settings', async () => {
+      const space1 = `${testPrefix}one_way_space1`;
+      const space2 = `${testPrefix}one_way_space2`;
+      
+      // Create federation with bidirectional=false
+      await holosphere.federate(space1, space2, null, null, false);
+      
+      // Allow time for federation to be created
+      await new Promise(resolve => setTimeout(resolve, 1000));
+      
+      // Verify federation structure:
+      // space1 has space2 in federation list
+      // space2 has space1 in notify list (this is different from the original test)
+      const fedInfo1 = await holosphere.getGlobal('federation', space1);
+      expect(fedInfo1).toBeTruthy();
+      expect(fedInfo1.federation).toContain(space2);
+      
+      const fedInfo2 = await holosphere.getGlobal('federation', space2);
+      expect(fedInfo2).toBeTruthy();
+      expect(fedInfo2.notify).toContain(space1);
+    });
+    
     test('should throw error when trying to federate a space with itself', async () => {
       const space = `${testPrefix}self_fed_space`;
       await expect(holosphere.federate(space, space, null))
@@ -107,16 +154,17 @@ describe('Federation Tests', () => {
     });
   });
   
-  describe('propagateToFederation', () => {
+  describe('propagate', () => {
     test('should handle propagation to non-federated space gracefully', async () => {
       const space = `${testPrefix}no_fed_space`;
       const data = { id: 'test-item', value: 42 };
       
       // Try to propagate to a space with no federation
-      const result = await holosphere.propagateToFederation(space, 'items', data);
+      const result = await holosphere.propagate(space, 'items', data);
       
       // Should have a message property but not fail
       expect(result).toBeDefined();
+      expect(result.message).toBeDefined();
     });
   });
 });

package/config/default.js

@@ -1 +0,0 @@
- 

package/services/environmentalApi.js

@@ -1,253 +0,0 @@
-import axios from 'axios';
-import dotenv from 'dotenv';
-
-dotenv.config();
-
-const logError = (service, error) => {
-    const status = error.response?.status;
-    const message = error.response?.data?.message || error.message;
-    console.error(`${service} API Error:`, { status, message });
-};
-
-/**
- * Fetch Carbon Sequestration Data (Using NASA POWER API)
- */
-export async function getCarbonSequestration(lat = 41.9, lon = 12.5) {
-    try {
-        const response = await axios.default.get(
-            `https://power.larc.nasa.gov/api/temporal/daily/point?parameters=T2M,PRECTOT,PS,WS2M&community=RE&longitude=${lon}&latitude=${lat}&start=20230101&end=20231231&format=JSON`
-        );
-        return response.data;
-    } catch (error) {
-        logError('Carbon Sequestration', error);
-        return null;
-    }
-}
-
-/**
- * Fetch Soil Carbon Data (Using ISRIC World Soil Information)
- */
-export async function getSoilCarbon(lat = 41.9, lon = 12.5) {
-    try {
-        const response = await axios.default.get(
-            `https://rest.isric.org/soilgrids/v2.0/properties/query?lat=${lat}&lon=${lon}&property=soc&depth=0-30cm&value=mean`
-        );
-        return response.data;
-    } catch (error) {
-        logError('Soil Carbon', error);
-        return null;
-    }
-}
-
-/**
- * Fetch Biodiversity Data (GBIF API)
- */
-export async function getBiodiversityData(countryCode = "ITA") {
-    try {
-        const response = await axios.default.get(`https://api.gbif.org/v1/occurrence/search?country=${countryCode}&limit=100`);
-        return response.data;
-    } catch (error) {
-        logError('Biodiversity', error);
-        return null;
-    }
-}
-
-/**
- * Fetch Vegetation Cover Data (Using NASA MODIS Vegetation Index)
- */
-export async function getVegetationCover(lat = 41.9, lon = 12.5) {
-    try {
-        const response = await axios.default.get(
-            `https://modis.ornl.gov/rst/api/v1/MOD13Q1/subset?latitude=${lat}&longitude=${lon}&band=NDVI&startDate=2023-01-01&endDate=2023-12-31`,
-            {
-                headers: {
-                    'Accept': 'application/json'
-                }
-            }
-        );
-        return response.data;
-    } catch (error) {
-        logError('Vegetation Cover', error);
-        return null;
-    }
-}
-
-/**
- * Fetch Air Quality Data (OpenWeather API)
- */
-export async function getAirQuality(lat = 41.9, lon = 12.5) {
-    try {
-        const response = await axios.default.get(
-            `https://api.openweathermap.org/data/2.5/air_pollution?lat=${lat}&lon=${lon}&appid=${process.env.OPENWEATHER_API_KEY}`
-        );
-        return response.data;
-    } catch (error) {
-        logError('Air Quality', error);
-        return null;
-    }
-}
-
-/**
- * Fetch Water Retention Data (Using USGS Water Services)
- */
-export async function getWaterRetention(lat = 41.9, lon = 12.5) {
-    try {
-        const response = await axios.default.get(
-            `https://waterservices.usgs.gov/nwis/iv/?format=json&sites=11447650&siteStatus=active`,
-            {
-                headers: {
-                    'Accept': 'application/json'
-                }
-            }
-        );
-        return response.data;
-    } catch (error) {
-        logError('Water Retention', error);
-        return null;
-    }
-}
-
-/**
- * Fetch Deforestation Data (Using World Bank Forest Data)
- */
-export async function getDeforestationData(countryCode = "ITA") {
-    try {
-        const response = await axios.default.get(
-            `https://api.worldbank.org/v2/country/${countryCode}/indicator/AG.LND.FRST.ZS?format=json`
-        );
-        return response.data;
-    } catch (error) {
-        logError('Deforestation', error);
-        return null;
-    }
-}
-
-/**
- * Fetch Flood Risk Data (Using USGS Water Services)
- */
-export async function getFloodRisk(lat = 41.9, lon = 12.5) {
-    try {
-        const response = await axios.default.get(
-            `https://waterservices.usgs.gov/nwis/iv/?format=json&stateCd=CA&parameterCd=00065&siteStatus=active`,
-            {
-                headers: {
-                    'Accept': 'application/json'
-                }
-            }
-        );
-        return response.data;
-    } catch (error) {
-        logError('Flood Risk', error);
-        return null;
-    }
-}
-
-/**
- * Fetch Food Security Data (World Bank API)
- */
-export async function getFoodSecurity(countryCode = "ITA") {
-    try {
-        const response = await axios.default.get(
-            `https://api.worldbank.org/v2/country/${countryCode}/indicator/SN.ITK.DEFC.ZS?format=json`
-        );
-        return response.data;
-    } catch (error) {
-        logError('Food Security', error);
-        return null;
-    }
-}
-
-/**
- * Fetch Local Employment Rate (World Bank API)
- */
-export async function getEmploymentRate(countryCode = "ITA") {
-    try {
-        const response = await axios.default.get(
-            `https://api.worldbank.org/v2/country/${countryCode}/indicator/SL.EMP.TOTL.SP.ZS?format=json`
-        );
-        return response.data;
-    } catch (error) {
-        logError('Employment Rate', error);
-        return null;
-    }
-}
-
-/**
- * Fetch Governance Score (World Bank API)
- */
-export async function getTransparencyScore(countryCode = "ITA") {
-    try {
-        const response = await axios.default.get(
-            `https://api.worldbank.org/v2/country/${countryCode}/indicator/GE.EST?format=json`
-        );
-        return response.data;
-    } catch (error) {
-        logError('Transparency Score', error);
-        return null;
-    }
-}
-
-/**
- * Fetch Blockchain Transactions (Etherscan API)
- */
-export async function getBlockchainTransactions(address = "0x0000000000000000000000000000000000000000") {
-    try {
-        const response = await axios.default.get(
-            `https://api.etherscan.io/api?module=account&action=txlist&address=${address}&startblock=0&endblock=99999999&sort=desc&apikey=${process.env.ETHERSCAN_API_KEY}`
-        );
-        return response.data;
-    } catch (error) {
-        logError('Blockchain Transactions', error);
-        return null;
-    }
-}
-
-/**
- * Fetch Circular Economy Data (Using World Bank Development Indicators)
- */
-export async function getCircularEconomyData(countryCode = "ITA") {
-    try {
-        const response = await axios.default.get(
-            `https://api.worldbank.org/v2/country/${countryCode}/indicator/EN.ATM.GHGT.KT.CE?format=json`
-        );
-        return response.data;
-    } catch (error) {
-        logError('Circular Economy', error);
-        return null;
-    }
-}
-
-/**
- * Fetch Renewable Energy Data (World Bank API)
- */
-export async function getRenewableEnergyData(countryCode = "ITA") {
-    try {
-        const response = await axios.default.get(
-            `https://api.worldbank.org/v2/country/${countryCode}/indicator/EG.FEC.RNEW.ZS?format=json`
-        );
-        return response.data;
-    } catch (error) {
-        logError('Renewable Energy', error);
-        return null;
-    }
-}
-
-/**
- * Fetch Climate Change Data (NOAA Climate API)
- */
-export async function getClimateChangeData(lat = 41.9, lon = 12.5) {
-    try {
-        const response = await axios.default.get(
-            `https://www.ncdc.noaa.gov/cdo-web/api/v2/data?datasetid=GHCND&latitude=${lat}&longitude=${lon}&startdate=2023-01-01&enddate=2023-12-31&limit=1000`,
-            {
-                headers: {
-                    'token': process.env.NOAA_API_KEY
-                }
-            }
-        );
-        return response.data;
-    } catch (error) {
-        logError('Climate Change', error);
-        return null;
-    }
-}