holosphere 1.1.4 → 1.1.5

package/holosphere.js

@@ -14,6 +14,7 @@ class HoloSphere {
      * @param {Gun|null} gunInstance - The Gun instance to use.
      */
     constructor(appname, strict = false, openaikey = null, gunInstance = null) {
+        console.log('HoloSphere v1.1.8'); 
         this.appname = appname
         this.strict = strict;
         this.validator = new Ajv2019({
@@ -24,7 +25,7 @@ class HoloSphere {
 
         // Use provided Gun instance or create new one
         this.gun = gunInstance || Gun({
-            peers: ['https://gun.holons.io/gun', 'https://59.src.eco/gun'],
+            peers: ['https://gun.holons.io/gun'],
             axe: false,
             // uuid: (content) => { // generate a unique id for each node
             //     console.log('uuid', content);
@@ -65,68 +66,50 @@ class HoloSphere {
             throw new Error('setSchema: Schema must have a type field');
         }
 
-        if (this.strict) {
-            const metaSchema = {
-                type: 'object',
-                required: ['type', 'properties'],
+        const metaSchema = {
+            type: 'object',
+            required: ['type', 'properties'],
+            properties: {
+                type: { type: 'string' },
                 properties: {
-                    type: { type: 'string' },
-                    properties: {
+                    type: 'object',
+                    additionalProperties: {
                         type: 'object',
-                        additionalProperties: {
-                            type: 'object',
-                            required: ['type'],
-                            properties: {
-                                type: { type: 'string' }
-                            }
+                        required: ['type'],
+                        properties: {
+                            type: { type: 'string' }
                         }
-                    },
-                    required: {
-                        type: 'array',
-                        items: { type: 'string' }
                     }
+                },
+                required: {
+                    type: 'array',
+                    items: { type: 'string' }
                 }
-            };
-
-            const valid = this.validator.validate(metaSchema, schema);
-            if (!valid) {
-                throw new Error(`Invalid schema structure: ${JSON.stringify(this.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');
-            }
+        const valid = this.validator.validate(metaSchema, schema);
+        if (!valid) {
+            throw new Error(`Invalid schema structure: ${JSON.stringify(this.validator.errors)}`);
         }
 
-        return new Promise((resolve, reject) => {
-            try {
-                const schemaString = JSON.stringify(schema);
-                const schemaData = {
-                    schema: schemaString,
-                    timestamp: Date.now(),
-                    // Only set owner if there's an authenticated space
-                    ...(this.currentSpace && { owner: this.currentSpace.alias })
-                };
+        if (!schema.properties || typeof schema.properties !== 'object') {
+            throw new Error('Schema must have properties in strict mode');
+        }
 
-                this.gun.get(this.appname)
-                    .get(lens)
-                    .get('schema')
-                    .put(schemaData, ack => {
-                        if (ack.err) {
-                            reject(new Error(ack.err));
-                        } else {
-                            // Add small delay to ensure data is written
-                            setTimeout(() => resolve(true), 50);
-                        }
-                    });
-            } catch (error) {
-                reject(error);
-            }
+        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
+        await this.putGlobal('schemas', {
+            id: lens,
+            schema: schema,
+            timestamp: Date.now(),
+            owner: this.currentSpace?.alias
         });
+
+        return true;
     }
 
     /**
@@ -139,39 +122,12 @@ class HoloSphere {
             throw new Error('getSchema: Missing lens parameter');
         }
 
-        return new Promise((resolve) => {
-            let timeout = setTimeout(() => {
-                console.warn('getSchema: Operation timed out');
-                resolve(null);
-            }, 5000);
-
-            this.gun.get(this.appname)
-                .get(lens)
-                .get('schema')
-                .once(data => {
-                    clearTimeout(timeout);
-                    if (!data) {
-                        resolve(null);
-                        return;
-                    }
+        const schemaData = await this.getGlobal('schemas', lens);
+        if (!schemaData || !schemaData.schema) {
+            return null;
+        }
 
-                    try {
-                        // Handle both new format and legacy format
-                        if (data.schema) {
-                            // New format with timestamp
-                            resolve(JSON.parse(data.schema));
-                        } else {
-                            // Legacy format or direct string
-                            const schemaStr = typeof data === 'string' ? data :
-                                Object.values(data).find(v => typeof v === 'string' && v.includes('"type":'));
-                            resolve(schemaStr ? JSON.parse(schemaStr) : null);
-                        }
-                    } catch (error) {
-                        console.error('getSchema: Error parsing schema:', error);
-                        resolve(null);
-                    }
-                });
-        });
+        return schemaData.schema;
     }
 
     // ================================ CONTENT FUNCTIONS ================================
@@ -567,11 +523,19 @@ class HoloSphere {
    * @returns {Promise<object>} - The parsed data.
    */
     async parse(rawData) {
+        let parsedData = {};
+
         if (!rawData) {
             throw new Error('parse: No data provided');
         }
 
         try {
+
+            if (typeof rawData === 'string') {
+                parsedData = await JSON.parse(rawData);
+            }
+
+
             if (rawData.soul) {
                 const data = await this.getNodeRef(rawData.soul).once();
                 if (!data) {
@@ -580,7 +544,7 @@ class HoloSphere {
                 return JSON.parse(data);
             }
 
-            let parsedData = {};
+       
             if (typeof rawData === 'object' && rawData !== null) {
                 if (rawData._ && rawData._["#"]) {
                     const pathParts = rawData._['#'].split('/');
@@ -600,11 +564,10 @@ class HoloSphere {
                 } else {
                     parsedData = rawData;
                 }
-            } else {
-                parsedData = JSON.parse(rawData);
             }
 
             return parsedData;
+
         } catch (error) {
             console.log("Parsing not a JSON, returning raw data", rawData);
             return rawData;
@@ -1423,23 +1386,27 @@ class HoloSphere {
      * @param {function} callback - The callback to execute on changes.
      */
     async subscribe(holon, lens, callback) {
-        const subscriptionId = this.generateSubscriptionId();
-        this.subscriptions[subscriptionId] = {
-            query: { holon, lens },
-            callback,
-            active: true
-        };
-
-        // Add cleanup to ensure callback isn't called after unsubscribe
+        const subscriptionId = this.generateId();
+        this.subscriptions[subscriptionId] =
+            this.gun.get(this.appname).get(holon).get(lens).map().on( async (data, key) => {
+                if (data) {
+                    try {
+                        let parsed = await this.parse(data)
+                        callback(parsed, key)
+                    } catch (error) {
+                        console.error('Error in subscribe:', error);
+                    }
+                }
+            })
         return {
             unsubscribe: () => {
-                if (this.subscriptions[subscriptionId]) {
-                    delete this.subscriptions[subscriptionId];
-                }
+                this.gun.get(this.appname).get(holon).get(lens).map().off()
+                delete this.subscriptions[subscriptionId];
             }
-        };
+        }
     }
 
+
     notifySubscribers(data) {
         Object.values(this.subscriptions).forEach(subscription => {
             if (subscription.active && this.matchesQuery(data, subscription.query)) {
@@ -1453,14 +1420,10 @@ class HoloSphere {
         return Date.now().toString(10) + Math.random().toString(2);
     }
 
-    generateSubscriptionId() {
-        return Date.now().toString(10) + Math.random().toString(2);
-    }
-
     matchesQuery(data, query) {
-        return data && query && 
-               data.holon === query.holon && 
-               data.lens === query.lens;
+        return data && query &&
+            data.holon === query.holon &&
+            data.lens === query.lens;
     }
 
     /**

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "holosphere",
-  "version": "1.1.4",
+  "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,12 +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"
   },
@@ -28,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/holosphere.test.js

@@ -7,10 +7,13 @@ describe('HoloSphere', () => {
         spacename: 'testuser',
         password: 'testpass'
     };
-    let holoSphere = new HoloSphere(testAppName, false);
+    let holoSphere;
+    let strictHoloSphere;
+
     beforeAll(async () => {
-        // Initialize HoloSphere once for all tests
-       
+        // Initialize HoloSphere instances once for all tests
+        holoSphere = new HoloSphere(testAppName, false);
+        strictHoloSphere = new HoloSphere(testAppName, true);
         
         // Set up test space and authenticate
         try {
@@ -26,15 +29,9 @@ describe('HoloSphere', () => {
             }
         }
         
-        // Ensure we're logged in
+        // Ensure both instances are logged in
         await holoSphere.login(testCredentials.spacename, testCredentials.password);
-    });
-
-    beforeEach(async () => {
-        // Ensure we're logged in before each test
-        if (!holoSphere.currentSpace || holoSphere.currentSpace.exp < Date.now()) {
-            await holoSphere.login(testCredentials.spacename, testCredentials.password);
-        }
+        await strictHoloSphere.login(testCredentials.spacename, testCredentials.password);
     });
 
     describe('Constructor', () => {
@@ -45,11 +42,8 @@ describe('HoloSphere', () => {
             expect(holoSphere.openai).toBeUndefined();
         });
 
-        test('should initialize with OpenAI when key provided', () => {
-            const hsWithAI = new HoloSphere(testAppName, false, 'fake-key');
-            expect(hsWithAI.openai).toBeDefined();
-            // Clean up additional instance
-            if (hsWithAI.gun) hsWithAI.gun.off();
+        test('should initialize with OpenAI', () => {
+            expect(new HoloSphere(testAppName, false, 'fake-key').openai).toBeDefined();
         });
     });
 
@@ -65,10 +59,8 @@ describe('HoloSphere', () => {
         };
 
         beforeEach(async () => {
-            // Ensure we're logged in before each schema test
-            if (!holoSphere.currentSpace || holoSphere.currentSpace.exp < Date.now()) {
-                await holoSphere.login(testCredentials.spacename, testCredentials.password);
-            }
+            // Clean up any existing schemas
+            await holoSphere.deleteAllGlobal('schemas');
         });
 
         test('should set and get schema', async () => {
@@ -84,11 +76,6 @@ describe('HoloSphere', () => {
         });
 
         test('should enforce strict mode schema validation', async () => {
-            const strictHoloSphere = new HoloSphere(testAppName, true);
-            
-            // Login to the strict instance
-            await strictHoloSphere.login(testCredentials.spacename, testCredentials.password);
-            
             const invalidSchema = {
                 type: 'object',
                 properties: {
@@ -98,9 +85,6 @@ describe('HoloSphere', () => {
 
             await expect(strictHoloSphere.setSchema(testLens, invalidSchema))
                 .rejects.toThrow();
-
-            // Clean up
-            await strictHoloSphere.logout();
         });
 
         test('should handle schema retrieval for non-existent lens', async () => {
@@ -110,10 +94,6 @@ describe('HoloSphere', () => {
 
         test('should maintain schema integrity across storage and retrieval', async () => {
             const testLens = 'schemaTestLens';
-            const strictHoloSphere = new HoloSphere(testAppName, true); 
-            
-            // Login to the strict instance
-            await strictHoloSphere.login(testCredentials.spacename, testCredentials.password);
             
             // Create test schemas of increasing complexity
             const testSchemas = [
@@ -151,7 +131,6 @@ describe('HoloSphere', () => {
 
                 // Store schema
                 await strictHoloSphere.setSchema(testLensWithIndex, schema);
-                
 
                 // Retrieve schema
                 const retrievedSchema = await strictHoloSphere.getSchema(testLensWithIndex);
@@ -187,17 +166,8 @@ describe('HoloSphere', () => {
 
                 // Clean up after each schema test
                 await strictHoloSphere.deleteAll('testHolon', testLensWithIndex);
-                await strictHoloSphere.gun.get(strictHoloSphere.appname)
-                    .get(testLensWithIndex)
-                    .get('schema')
-                    .put(null);
             }
-
-            // Clean up the strict instance
-            if (strictHoloSphere.gun) {
-                await strictHoloSphere.logout();
-            }
-        }, 10000); // Increase timeout to 10 seconds
+        }, 10000);
 
         test('should handle concurrent schema operations', async () => {
             const baseLens = 'concurrentSchemaTest';
@@ -272,10 +242,7 @@ describe('HoloSphere', () => {
 
         afterEach(async () => {
             // Clean up schemas after each test
-            await holoSphere.gun.get(holoSphere.appname)
-                    .get(testLens)
-                    .get('schema')
-                    .put(null);
+            await holoSphere.deleteAllGlobal('schemas');
         });
     });
 
@@ -355,11 +322,6 @@ describe('HoloSphere', () => {
         });
 
         test('should enforce strict mode data validation', async () => {
-            const strictHoloSphere = new HoloSphere(testAppName, true);
-            
-            // Login to the strict instance
-            await strictHoloSphere.login(testCredentials.spacename, testCredentials.password);
-            
             // Define schema for strict mode tests
             const strictSchema = {
                 type: 'object',
@@ -376,9 +338,6 @@ describe('HoloSphere', () => {
             // Try to put data without schema in strict mode
             await expect(strictHoloSphere.put(testHolon, 'no-schema-lens', validData))
                 .rejects.toThrow('Schema required in strict mode');
-
-            // Clean up
-            await strictHoloSphere.logout();
         });
 
         test('should maintain content integrity in holon storage', async () => {
@@ -1015,14 +974,13 @@ describe('HoloSphere', () => {
 
     describe('OpenAI Integration', () => {
         test('should handle missing OpenAI key', async () => {
-            const noAIHoloSphere = new HoloSphere('test');
-            const result = await noAIHoloSphere.summarize('test content');
-            expect(result).toBe('OpenAI not initialized, please specify the API key in the constructor.');
+            expect(await holoSphere.summarize('test content'))
+                .toBe('OpenAI not initialized, please specify the API key in the constructor.');
         });
 
         test.skip('should summarize content with valid OpenAI key', async () => {
-            const hsWithAI = new HoloSphere('test', false, process.env.OPENAI_API_KEY);
-            const summary = await hsWithAI.summarize('Test content to summarize');
+            const summary = await new HoloSphere('test', false, process.env.OPENAI_API_KEY)
+                .summarize('Test content to summarize');
             expect(typeof summary).toBe('string');
             expect(summary.length).toBeGreaterThan(0);
         });
@@ -1038,13 +996,21 @@ describe('HoloSphere', () => {
         await holoSphere.deleteAllGlobal('testTable');
         await holoSphere.deleteAllGlobal('testGlobalTable');
         await holoSphere.deleteAllGlobal('concurrentGlobalTest');
+        await holoSphere.deleteAllGlobal('schemas');
         
         // Clean up test space
         await holoSphere.deleteGlobal('spaces', testCredentials.spacename);
         
-        // Logout
+        // Logout both instances
         if (holoSphere.currentSpace) {
             await holoSphere.logout();
         }
+        if (strictHoloSphere.currentSpace) {
+            await strictHoloSphere.logout();
+        }
+
+        // Clean up Gun instances
+        if (holoSphere.gun) holoSphere.gun.off();
+        if (strictHoloSphere.gun) strictHoloSphere.gun.off();
     });
 }); 

package/test/jest.setup.js

@@ -0,0 +1,5 @@
+
+// Mock process.env
+process.env.OPENWEATHER_API_KEY = 'test-api-key';
+process.env.ETHERSCAN_API_KEY = 'test-api-key';
+process.env.NOAA_API_KEY = 'test-api-key';