holosphere 1.1.3 → 1.1.5

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "holosphere",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "Holonic Geospatial Communication Infrastructure",
   "main": "holosphere.js",
   "types": "holosphere.d.ts",
   "type": "module",
   "scripts": {
-    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js ./test",
     "build": "",
     "prepare": "npm run build"
   },
@@ -14,11 +14,14 @@
   "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"
   },
@@ -27,6 +30,9 @@
     "transform": {},
     "moduleNameMapper": {
       "^(\\.{1,2}/.*)\\.js$": "$1"
-    }
+    },
+    "setupFilesAfterEnv": [
+      "<rootDir>/test/jest.setup.js"
+    ]
   }
 }

package/services/environmentalApi.js

@@ -0,0 +1,253 @@
+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;
+    }
+} 

package/services/environmentalApi.test.js

@@ -0,0 +1,164 @@
+import { jest } from '@jest/globals';
+
+// Mock axios before importing the modules that use it
+jest.mock('axios', () => ({
+    default: {
+        get: jest.fn()
+    }
+}));
+
+// Import axios after mocking
+import axios from 'axios';
+
+// Import the API functions
+import {
+    getCarbonSequestration,
+    getSoilCarbon,
+    getBiodiversityData,
+    getVegetationCover,
+    getAirQuality,
+    getWaterRetention,
+    getDeforestationData,
+    getFloodRisk,
+    getFoodSecurity,
+    getEmploymentRate,
+    getTransparencyScore,
+    getBlockchainTransactions,
+    getCircularEconomyData,
+    getRenewableEnergyData,
+    getClimateChangeData
+} from './environmentalApi.js';
+
+describe('Environmental API Tests', () => {
+    // Increase timeout for real API calls
+    jest.setTimeout(60000);
+
+    const ROME_LAT = 41.9;
+    const ROME_LON = 12.5;
+    const COUNTRY_CODE = 'ITA';
+    const ETH_ADDRESS = '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe';
+
+    test('getCarbonSequestration returns NASA POWER data', async () => {
+        const result = await getCarbonSequestration(ROME_LAT, ROME_LON);
+        expect(result).not.toBeNull();
+        expect(result.messages).toBeDefined();
+        expect(result.parameters).toBeDefined();
+        expect(result.parameters).toHaveProperty('T2M');
+        expect(result.parameters).toHaveProperty('PRECTOT');
+    });
+
+    test('getSoilCarbon returns ISRIC soil data', async () => {
+        const result = await getSoilCarbon(ROME_LAT, ROME_LON);
+        expect(result).not.toBeNull();
+        expect(result.properties).toBeDefined();
+        expect(result.properties.soc).toBeDefined();
+    });
+
+    test('getBiodiversityData returns GBIF data', async () => {
+        const result = await getBiodiversityData(COUNTRY_CODE);
+        expect(result).not.toBeNull();
+        expect(result.count).toBeDefined();
+        expect(result.results).toBeDefined();
+        expect(Array.isArray(result.results)).toBeTruthy();
+    });
+
+    test('getVegetationCover returns MODIS NDVI data', async () => {
+        const result = await getVegetationCover(ROME_LAT, ROME_LON);
+        expect(result).not.toBeNull();
+        expect(result.subset || result.data).toBeDefined();
+    });
+
+    test('getAirQuality returns OpenWeather data', async () => {
+        const result = await getAirQuality(ROME_LAT, ROME_LON);
+        expect(result).not.toBeNull();
+        expect(result.list).toBeDefined();
+        expect(result.list[0].main).toBeDefined();
+        expect(result.list[0].components).toBeDefined();
+    });
+
+    test('getWaterRetention returns USGS data', async () => {
+        const result = await getWaterRetention(ROME_LAT, ROME_LON);
+        expect(result).not.toBeNull();
+        expect(result.value || result.timeSeries).toBeDefined();
+    });
+
+    test('getDeforestationData returns World Bank forest data', async () => {
+        const result = await getDeforestationData(COUNTRY_CODE);
+        expect(result).not.toBeNull();
+        expect(Array.isArray(result)).toBeTruthy();
+        if (result.length > 1) {
+            expect(result[1][0]).toHaveProperty('indicator');
+            expect(result[1][0].indicator.id).toBe('AG.LND.FRST.ZS');
+        }
+    });
+
+    test('getFloodRisk returns USGS gauge data', async () => {
+        const result = await getFloodRisk(ROME_LAT, ROME_LON);
+        expect(result).not.toBeNull();
+        expect(result.value || result.timeSeries).toBeDefined();
+    });
+
+    test('getFoodSecurity returns World Bank data', async () => {
+        const result = await getFoodSecurity(COUNTRY_CODE);
+        expect(result).not.toBeNull();
+        expect(Array.isArray(result)).toBeTruthy();
+        if (result.length > 1) {
+            expect(result[1][0]).toHaveProperty('indicator');
+            expect(result[1][0].indicator.id).toBe('SN.ITK.DEFC.ZS');
+        }
+    });
+
+    test('getEmploymentRate returns World Bank data', async () => {
+        const result = await getEmploymentRate(COUNTRY_CODE);
+        expect(result).not.toBeNull();
+        expect(Array.isArray(result)).toBeTruthy();
+        if (result.length > 1) {
+            expect(result[1][0]).toHaveProperty('indicator');
+            expect(result[1][0].indicator.id).toBe('SL.EMP.TOTL.SP.ZS');
+        }
+    });
+
+    test('getTransparencyScore returns World Bank governance data', async () => {
+        const result = await getTransparencyScore(COUNTRY_CODE);
+        expect(result).not.toBeNull();
+        expect(Array.isArray(result)).toBeTruthy();
+        if (result.length > 1) {
+            expect(result[1][0]).toHaveProperty('indicator');
+            expect(result[1][0].indicator.id).toBe('GE.EST');
+        }
+    });
+
+    test('getBlockchainTransactions returns Etherscan data', async () => {
+        const result = await getBlockchainTransactions(ETH_ADDRESS);
+        expect(result).not.toBeNull();
+        expect(result.status).toBeDefined();
+        expect(result.result).toBeDefined();
+        expect(Array.isArray(result.result)).toBeTruthy();
+    });
+
+    test('getCircularEconomyData returns World Bank emissions data', async () => {
+        const result = await getCircularEconomyData(COUNTRY_CODE);
+        expect(result).not.toBeNull();
+        expect(Array.isArray(result)).toBeTruthy();
+        if (result.length > 1) {
+            expect(result[1][0]).toHaveProperty('indicator');
+            expect(result[1][0].indicator.id).toBe('EN.ATM.GHGT.KT.CE');
+        }
+    });
+
+    test('getRenewableEnergyData returns World Bank energy data', async () => {
+        const result = await getRenewableEnergyData(COUNTRY_CODE);
+        expect(result).not.toBeNull();
+        expect(Array.isArray(result)).toBeTruthy();
+        if (result.length > 1) {
+            expect(result[1][0]).toHaveProperty('indicator');
+            expect(result[1][0].indicator.id).toBe('EG.FEC.RNEW.ZS');
+        }
+    });
+
+    test('getClimateChangeData returns NOAA data', async () => {
+        const result = await getClimateChangeData(ROME_LAT, ROME_LON);
+        expect(result).not.toBeNull();
+        expect(result.metadata || result.results).toBeDefined();
+    });
+}); 

package/test/ai.test.js

@@ -0,0 +1,233 @@
+import HoloSphere from '../holosphere.js';
+import * as h3 from 'h3-js';
+import { jest } from '@jest/globals';
+import 'dotenv/config';
+
+// Set global timeout for all tests
+jest.setTimeout(120000);
+
+describe('AI Operations', () => {
+    let holoSphere;
+    const testAppName = 'test-ai-app';
+    const testHolon = h3.latLngToCell(40.7128, -74.0060, 7);
+    const testLens = 'aiTestLens';
+    const testCredentials = {
+        spacename: 'aitest@example.com',
+        password: 'AiTest123!'
+    };
+
+    beforeAll(async () => {
+        holoSphere = new HoloSphere(testAppName, false, process.env.OPENAI_API_KEY);
+        
+        // Clean up any existing test space and data
+        try {
+            await holoSphere.deleteAllGlobal('federation');
+            await holoSphere.deleteGlobal('spaces', testCredentials.spacename);
+        } catch (error) {
+            console.log('Cleanup error (can be ignored):', error);
+        }
+        // Create and login to test space
+        await holoSphere.createSpace(testCredentials.spacename, testCredentials.password);
+        await holoSphere.login(testCredentials.spacename, testCredentials.password);
+        // Set up base schema for compute tests
+        const baseSchema = {
+            type: 'object',
+            properties: {
+                id: { type: 'string' },
+                content: { type: 'string' },
+                value: { type: 'number' },
+                tags: { type: 'array', items: { type: 'string' } },
+                timestamp: { type: 'number' }
+            },
+            required: ['id']
+        };
+        
+        await holoSphere.setSchema(testLens, baseSchema);
+    }, 30000);
+
+    describe('Summarize Operations', () => {
+        test('should generate summary from text content', async () => {
+            const testContent = `
+                The HoloSphere project is a decentralized data management system.
+                It uses Gun.js for peer-to-peer data synchronization and SEA for encryption.
+                The system supports federation between spaces and implements schema validation.
+                Data can be organized in holons and viewed through different lenses.
+            `;
+
+            const summary = await holoSphere.summarize(testContent);
+            console.log("summary",summary);
+            expect(summary).toBeDefined();
+            expect(typeof summary).toBe('string');
+            expect(summary.length).toBeGreaterThan(0);
+        }, 15000);
+
+        test('should handle empty content gracefully', async () => {
+            const summary = await holoSphere.summarize('');
+            expect(summary).toBeDefined();
+            expect(typeof summary).toBe('string');
+        }, 10000);
+
+        test('should handle long content', async () => {
+            const longContent = Array(10).fill(
+                'This is a long paragraph of text that needs to be summarized. ' +
+                'It contains multiple sentences with various information. ' +
+                'The summary should capture the key points while remaining concise.'
+            ).join('\n');
+
+            const summary = await holoSphere.summarize(longContent);
+            expect(summary).toBeDefined();
+            expect(typeof summary).toBe('string');
+            expect(summary.length).toBeLessThan(longContent.length);
+        }, 20000);
+
+        test('should fail gracefully without API key', async () => {
+            const noKeyHoloSphere = new HoloSphere(testAppName, false);
+            const result = await noKeyHoloSphere.summarize('Test content');
+            expect(result).toBe('OpenAI not initialized, please specify the API key in the constructor.');
+        });
+    });
+
+    describe('Compute Operations', () => {
+        beforeEach(async () => {
+            // Ensure we're logged in
+            if (!holoSphere.currentSpace) {
+                await holoSphere.login(testCredentials.spacename, testCredentials.password);
+            }
+            
+            // Clean up any existing test data
+            await holoSphere.deleteAll(testHolon, testLens);
+        }, 15000);
+
+        test('should compute summaries for nested holons', async () => {
+            const childHolon = h3.cellToChildren(testHolon, 8)[0];
+            const testData = {
+                id: 'test1',
+                content: 'This is test content for the child holon that should be summarized.',
+                timestamp: Date.now()
+            };
+
+            // Put data in child holon
+            await holoSphere.put(childHolon, testLens, testData);
+
+            // Compute summaries
+            const result = await holoSphere.compute(childHolon, testLens, {
+                operation: 'summarize',
+                fields: ['content'],
+                targetField: 'summary'
+            });
+
+            expect(result).toBeDefined();
+            expect(result.id).toMatch(/_summarize$/);
+            expect(result.summary).toBeDefined();
+            expect(typeof result.summary).toBe('string');
+        }, 60000);
+
+        test('should compute aggregations for numeric fields', async () => {
+            const childHolon = h3.cellToChildren(testHolon, 8)[0];
+            const testData = [
+                { id: 'test1', value: 10, timestamp: Date.now() },
+                { id: 'test2', value: 20, timestamp: Date.now() }
+            ];
+
+            // Put test data
+            await Promise.all(testData.map(data => holoSphere.put(childHolon, testLens, data)));
+
+            // Compute aggregation
+            const result = await holoSphere.compute(childHolon, testLens, {
+                operation: 'aggregate',
+                fields: ['value']
+            });
+
+            expect(result).toBeDefined();
+            expect(result.id).toMatch(/_aggregate$/);
+            expect(result.value).toBe(30);
+        }, 30000);
+
+        test('should compute concatenations for array fields', async () => {
+            const childHolon = h3.cellToChildren(testHolon, 8)[0];
+            const testData = [
+                { id: 'test1', tags: ['tag1', 'tag2'], timestamp: Date.now() },
+                { id: 'test2', tags: ['tag2', 'tag3'], timestamp: Date.now() }
+            ];
+
+            // Put test data
+            await Promise.all(testData.map(data => holoSphere.put(childHolon, testLens, data)));
+
+            // Compute concatenation
+            const result = await holoSphere.compute(childHolon, testLens, {
+                operation: 'concatenate',
+                fields: ['tags']
+            });
+
+            expect(result).toBeDefined();
+            expect(result.id).toMatch(/_concatenate$/);
+            expect(result.tags).toEqual(['tag1', 'tag2', 'tag3']);
+        }, 30000);
+
+
+        test('should handle empty holons', async () => {
+            // Clean up any existing data first
+            await holoSphere.deleteAll(testHolon, testLens);
+       
+            // Try to compute on empty holon
+            const result = await holoSphere.compute(testHolon, testLens, {
+                operation: 'summarize',
+                fields: ['content']
+            });
+    
+            expect(result).toBeNull();
+        }, 30000);
+
+        test('should compute hierarchy across multiple levels', async () => {
+            const childHolon = h3.cellToChildren(testHolon, 9)[0];
+            const testData = {
+                id: 'test-hierarchy',
+                content: 'Content for testing hierarchy computation',
+                value: 42,
+                tags: ['test', 'hierarchy'],
+                timestamp: Date.now()
+            };
+
+            // Put test data
+            await holoSphere.put(childHolon, testLens, testData);
+      
+            // Compute hierarchy
+            const results = await holoSphere.computeHierarchy(childHolon, testLens, {
+                operation: 'summarize',
+                fields: ['content'],
+                targetField: 'summary'
+            }, 3);
+         
+            expect(Array.isArray(results)).toBe(true);
+            expect(results.length).toBeGreaterThan(0);
+            results.forEach(result => {
+                expect(result.id).toMatch(/_summarize$/);
+                expect(result.summary).toBeDefined();
+                expect(typeof result.summary).toBe('string');
+            });
+        }, 60000);
+    });
+
+    afterEach(async () => {
+        // Clean up test data
+        if (holoSphere.currentSpace) {
+            await holoSphere.deleteAll(testHolon, testLens);
+        }
+    }, 15000);
+
+    afterAll(async () => {
+        // Clean up test space and data
+        try {
+            await holoSphere.deleteAll(testHolon, testLens);
+            await holoSphere.deleteGlobal('spaces', testCredentials.spacename);
+            await holoSphere.deleteAllGlobal('federation');
+        } catch (error) {
+            console.log('Cleanup error (can be ignored):', error);
+        }
+
+        // Clean up Gun instance
+        if (holoSphere.gun) {
+            holoSphere.gun.off();
+        }
+    }, 30000);
+});