holosphere 1.1.0 → 1.1.1

package/holosphere.d.ts

@@ -1,48 +1,43 @@
-declare module 'holosphere' {
-    export default class HoloSphere {
-        constructor(appName: string, strict?: boolean | null, openaikey?: string | null);
-        
-        // User Management
-        createUser(username: string, password: string): Promise<object>;
-        login(username: string, password: string): Promise<object>;
-        logout(): Promise<void>;
-
-        // Schema Operations
-        setSchema(lens: string, schema: object): Promise<void>;
-        getSchema(lens: string): Promise<object | null>;
-
-        // Encryption Operations
-        encrypt(data: any, secret: string): Promise<string>;
-        decrypt(encryptedData: string, secret: string): Promise<any>;
-
-        // Hex Data Operations
-        put(holon: string, lens: string, content: object, encrypt?: boolean, secret?: string | null): Promise<void>;
-        get(holon: string, lens: string, key: string): Promise<any | null>;
-        delete(holon: string, lens: string, contentId: string): Promise<void>;
-        getAll(holon: string, lens: string, secret?: string | null): Promise<Array<any>>;
-        deleteAll(holon: string, lens: string): Promise<void>; 
-     
-        // Node Operations
-        putNode(holon: string, lens: string, node: object): Promise<void>;
-        getNode(holon: string, lens: string, key: string): Promise<any>;
-        deleteNode(holon: string, lens: string, key: string): Promise<void>;
-
-        // Global Data Operations
-        putGlobal(tableName: string, data: object): Promise<void>;
-        getGlobal(tableName: string, key: string): Promise<object | null>;
-        deleteGlobal(tableName: string, key: string): Promise<void>;
-        getAllGlobal(tableName: string): Promise<object | null>;
-        deleteAllGlobal(tableName: string): Promise<void>;
-
-        // Geospatial Operations
-        getHex(lat: number, lng: number, resolution: number): Promise<string>;
-        getScalespace(lat: number, lng: number): string[];
-        getHexScalespace(hex: string): string[];
-        compute(hex: string, lens: string, operation: string): Promise<void>;
-        upcast(hex: string, lens: string, content: any): Promise<any>;
-
-        // Subscription
-        subscribe(holon: string, lens: string, callback: (data: any, key: string) => void): void;
-        subscribeGlobal(tableName: string, callback: (data: any, key: string) => void): void;
-    }
-}
+declare class HoloSphere {
+    private appname;
+    private strict;
+    private validator;
+    private gun;
+    private openai?;
+    /**
+     * Initializes a new instance of the HoloSphere class.
+     * @param {string} appname - The name of the application.
+     * @param {boolean} strict - Whether to enforce strict schema validation.
+     * @param {string|null} openaikey - The OpenAI API key.
+     */
+    constructor(appname: string, strict?: boolean, openaikey?: string | null);
+    setSchema(lens: string, schema: object): Promise<boolean>;
+    getSchema(lens: string): Promise<object | null>;
+    put(holon: string, lens: string, data: object): Promise<boolean>;
+    get(holon: string, lens: string, key: string): Promise<any | null>;
+    getAll(holon: string, lens: string): Promise<Array<any>>;
+    delete(holon: string, lens: string, key: string): Promise<void>;
+    deleteAll(holon: string, lens: string): Promise<boolean>;
+    putNode(holon: string, lens: string, node: object): Promise<boolean>;
+    getNode(holon: string, lens: string, key: string): Promise<any | null>;
+    deleteNode(holon: string, lens: string, key: string): Promise<boolean>;
+    putGlobal(tableName: string, data: object): Promise<void>;
+    getGlobal(tableName: string, key: string): Promise<object | null>;
+    getAllGlobal(tableName: string): Promise<object | null>;
+    deleteGlobal(tableName: string, key: string): Promise<void>;
+    deleteAllGlobal(tableName: string): Promise<void>;
+    getHolon(lat: number, lng: number, resolution: number): Promise<string>;
+    getScalespace(lat: number, lng: number): string[];
+    getHolonScalespace(holon: string): string[];
+    compute(holon: string, lens: string, operation: string): Promise<void>;
+    private parse;
+    subscribe(holon: string, lens: string, callback: (data: any, key: string) => void): void;
+    subscribeGlobal(tableName: string, callback: (data: any, key: string) => void): void;
+    /**
+     * Summarizes provided history text using OpenAI.
+     * @param {string} history - The history text to summarize.
+     * @returns {Promise<string>} - The summarized text.
+     */
+    private summarize;
+}
+export default HoloSphere;

package/holosphere.js

@@ -3,6 +3,7 @@ import OpenAI from 'openai';
 import Gun from 'gun'
 import Ajv2019 from 'ajv/dist/2019.js'
 
+
 class HoloSphere {
     /**
      * Initializes a new instance of the HoloSphere class.
@@ -13,13 +14,13 @@ class HoloSphere {
     constructor(appname, strict = false, openaikey = null) {
         this.appname = appname
         this.strict = strict;
-        this.validator = new Ajv2019({ 
+        this.validator = new Ajv2019({
             allErrors: true,
             strict: false,  // Keep this false to avoid Ajv strict mode issues
             validateSchema: true // Always validate schemas
         });
         this.gun = Gun({
-            peers: ['http://gun.holons.io', 'https://59.src.eco/gun'],
+            peers: ['https://gun.holons.io', 'https://59.src.eco/gun'],
             axe: false,
             // uuid: (content) => { // generate a unique id for each node
             //     console.log('uuid', content);
@@ -61,7 +62,7 @@ class HoloSphere {
                     required: ['type', 'properties'],
                     properties: {
                         type: { type: 'string' },
-                        properties: { 
+                        properties: {
                             type: 'object',
                             additionalProperties: {
                                 type: 'object',
@@ -142,16 +143,16 @@ class HoloSphere {
                         resolve(null);
                         return;
                     }
-                    
+
                     try {
                         // If data is already a string, parse it
                         if (typeof data === 'string') {
                             resolve(JSON.parse(data));
-                        } 
+                        }
                         // If data is an object with a string value (GunDB format)
                         else if (typeof data === 'object' && data !== null) {
-                            const schemaStr = Object.values(data).find(v => 
-                                typeof v === 'string' && v.includes('"type":')); 
+                            const schemaStr = Object.values(data).find(v =>
+                                typeof v === 'string' && v.includes('"type":'));
                             if (schemaStr) {
                                 resolve(JSON.parse(schemaStr));
                             } else {
@@ -210,7 +211,7 @@ class HoloSphere {
         return new Promise((resolve) => {
             try {
                 const payload = JSON.stringify(data);
-                
+
                 this.gun.get(this.appname)
                     .get(holon)
                     .get(lens)
@@ -251,7 +252,7 @@ class HoloSphere {
         return new Promise((resolve) => {
             let output = [];
             let counter = 0;
-            
+
             this.gun.get(this.appname).get(holon).get(lens).once((data, key) => {
                 if (!data) {
                     resolve(output);
@@ -259,13 +260,12 @@ class HoloSphere {
                 }
 
                 const mapLength = Object.keys(data).length - 1;
-                
+
                 this.gun.get(this.appname).get(holon).get(lens).map().once(async (itemdata, key) => {
                     counter += 1;
                     if (itemdata) {
                         try {
-                            const parsed = JSON.parse(itemdata);
-                            
+                            const parsed = await this.parse(itemdata);
                             if (schema) {
                                 const valid = this.validator.validate(schema, parsed);
                                 if (valid) {
@@ -296,6 +296,65 @@ class HoloSphere {
         });
     }
 
+    /**
+   * Parses data from GunDB, handling various data formats and references.
+   * @param {*} data - The data to parse, could be a string, object, or GunDB reference.
+   * @returns {Promise<object>} - The parsed data.
+   */
+    async parse(rawData) {
+        let parsedData = {};
+        if (rawData.soul) {
+            console.log('Parsing link:', rawData.soul);
+            this.getNodeRef(rawData.soul).once (data => {return JSON.parse(data)});
+        }
+
+        if (typeof rawData === 'object' && rawData !== null) {
+            if (rawData._ && rawData._["#"]) {
+                console.log('Parsing object reference:', rawData._['#']);
+                // If the data is a reference, fetch the actual content
+                let pathParts = rawData._['#'].split('/');
+                let hexId = pathParts[1];
+                let lensId = pathParts[2];
+                let dataKey = pathParts[3];
+                parsedData = await this.get(hexId, lensId, dataKey);
+            } else if (rawData._ && rawData._['>']) {
+                console.log('Parsing objectnode:', rawData._['>']);
+                // This might be a GunDB node, try to get its value
+                const nodeValue = Object.values(rawData).find(v => typeof v !== 'object' && v !== '_');
+                if (nodeValue) {
+                    try {
+                        parsedData = JSON.parse(nodeValue);
+                    } catch (e) {
+                        console.log('Invalid JSON in node value:', nodeValue);
+                        parsedData = nodeValue; // return the raw data
+                    }
+                } else {
+                    console.log('Unable to parse GunDB node:', rawData);
+                    parsedData = rawData; // return the original data
+                }
+            } else {
+                // Treat it as object data
+                console.log('Parsing object data:', rawData);
+                parsedData = rawData;
+            }
+        } else {
+            // If it's not an object, try parsing it as JSON
+            try {
+                parsedData = JSON.parse(rawData);
+                //if the data has a soul, return the soul node
+                if (parsedData.soul) {
+                    console.log('Parsing link:', parsedData.soul);
+                    parsedData = await this.get(parsedData.soul.split('/')[1], parsedData.soul.split('/')[2], parsedData.soul.split('/')[3]);
+                }
+            } catch (e) {
+                console.log('Failed to parse, returning raw data', e);
+                parsedData = rawData; // return the raw data
+            }
+        }
+
+        return parsedData;
+    }
+
     /**
      * Retrieves a specific key from the specified holon and lens.
      * @param {string} holon - The holon identifier.
@@ -322,17 +381,17 @@ class HoloSphere {
                 .get(holon)
                 .get(lens)
                 .get(key)
-                .once((data) => {
+                .once((data,key) => {
                     clearTimeout(timeout);
-                    
+                   
                     if (!data) {
                         resolve(null);
                         return;
                     }
 
                     try {
-                        const parsed = JSON.parse(data);
-                        
+                        const parsed = this.parse(data);
+
                         // Validate against schema if one exists
                         if (schema) {
                             const valid = this.validator.validate(schema, parsed);
@@ -344,7 +403,6 @@ class HoloSphere {
                                 }
                             }
                         }
-                        
                         resolve(parsed);
                     } catch (error) {
                         console.error('Error parsing data:', error);
@@ -360,17 +418,17 @@ class HoloSphere {
      * @param {string} lens - The lens from which to delete the key.
      * @param {string} key - The specific key to delete.
      */
-    async delete (holon, lens, key) {
-            return new Promise((resolve, reject) => {
-                this.gun.get(this.appname).get(holon).get(lens).get(key).put(null, ack => {
-                    if (ack.err) {
-                        resolve(ack.err);
-                    } else {
-                        resolve(ack.ok);
-                    }
-                });
+    async delete(holon, lens, key) {
+        return new Promise((resolve, reject) => {
+            this.gun.get(this.appname).get(holon).get(lens).get(key).put(null, ack => {
+                if (ack.err) {
+                    resolve(ack.err);
+                } else {
+                    resolve(ack.ok);
+                }
             });
-        }
+        });
+    }
 
     /**
      * Deletes all keys from a given holon and lens.
@@ -386,7 +444,7 @@ class HoloSphere {
 
         return new Promise((resolve) => {
             let deletionPromises = [];
-            
+
             // First get all the data to find keys to delete
             this.gun.get(this.appname).get(holon).get(lens).once((data) => {
                 if (!data) {
@@ -396,7 +454,7 @@ class HoloSphere {
 
                 // Get all keys except Gun's metadata key '_'
                 const keys = Object.keys(data).filter(key => key !== '_');
-                
+
                 // Create deletion promises for each key
                 keys.forEach(key => {
                     deletionPromises.push(
@@ -432,8 +490,17 @@ class HoloSphere {
      * @param {object} node - The node to store.
      */
     async putNode(holon, lens, node) {
-            this.gun.get(this.appname).get(holon).get(lens).put(node)
-        }
+        return new Promise((resolve) => {
+            this.gun.get(this.appname).get(holon).get(lens).put(node, ack => {
+                if (ack.err) {
+                    console.error("Error adding data to GunDB:", ack.err);
+                    resolve(false);
+                } else {
+                    resolve(true);
+                }
+            });
+        });
+    }
 
     /**
    * Retrieves a specific gun node from the specified holon and lens.
@@ -442,27 +509,26 @@ class HoloSphere {
    * @param {string} key - The specific key to retrieve.
    * @returns {Promise<object|null>} - The retrieved node or null if not found.
    */
-    async getNode(holon, lens, key) {
+    getNode(holon, lens, key) {
         if (!holon || !lens || !key) {
             console.error('getNode: Missing required parameters');
             return null;
         }
 
-        return new Promise((resolve) => {
-            let timeout = setTimeout(() => {
-                console.warn('getNode: Operation timed out');
-                resolve(null);
-            }, 5000);
+        return this.gun.get(this.appname)
+            .get(holon)
+            .get(lens)
+            .get(key)
 
-            this.gun.get(this.appname)
-                .get(holon)
-                .get(lens)
-                .get(key)
-                .once((data) => {
-                    clearTimeout(timeout);
-                    resolve(data || null);
-                });
+    }
+
+    getNodeRef(soul) {
+        const parts = soul.split('/');
+        let ref = this.gun.get(this.appname);
+        parts.forEach(part => {
+            ref = ref.get(part);
         });
+        return ref;
     }
 
     /**
@@ -503,32 +569,32 @@ class HoloSphere {
      */
     async putGlobal(tableName, data) {
 
-            return new Promise((resolve, reject) => {
-                if (!tableName || !data) {
-                    reject(new Error('Table name and data are required'));
-                    return;
-                }
+        return new Promise((resolve, reject) => {
+            if (!tableName || !data) {
+                reject(new Error('Table name and data are required'));
+                return;
+            }
 
 
-                if (data.id) {
-                    this.gun.get(this.appname).get(tableName).get(data.id).put(JSON.stringify(data), ack => {
-                        if (ack.err) {
-                            reject(new Error(ack.err));
-                        } else {
-                            resolve();
-                        }
-                    });
-                } else {
-                    this.gun.get(this.appname).get(tableName).put(JSON.stringify(data), ack => {
-                        if (ack.err) {
-                            reject(new Error(ack.err));
-                        } else {
-                            resolve();
-                        }
-                    });
-                }
-            });
-        }
+            if (data.id) {
+                this.gun.get(this.appname).get(tableName).get(data.id).put(JSON.stringify(data), ack => {
+                    if (ack.err) {
+                        reject(new Error(ack.err));
+                    } else {
+                        resolve();
+                    }
+                });
+            } else {
+                this.gun.get(this.appname).get(tableName).put(JSON.stringify(data), ack => {
+                    if (ack.err) {
+                        reject(new Error(ack.err));
+                    } else {
+                        resolve();
+                    }
+                });
+            }
+        });
+    }
 
     /**
     * Retrieves a specific key from a global table.
@@ -537,21 +603,21 @@ class HoloSphere {
     * @returns {Promise<object|null>} - The parsed data for the key or null if not found.
     */
     async getGlobal(tableName, key) {
-            return new Promise((resolve) => {
-                this.gun.get(this.appname).get(tableName).get(key).once((data) => {
-                    if (!data) {
-                        resolve(null);
-                        return;
-                    }
-                    try {
-                        const parsed = this.parse(data);
-                        resolve(parsed);
-                    } catch (e) {
-                        resolve(null);
-                    }
-                });
+        return new Promise((resolve) => {
+            this.gun.get(this.appname).get(tableName).get(key).once((data) => {
+                if (!data) {
+                    resolve(null);
+                    return;
+                }
+                try {
+                    const parsed = this.parse(data);
+                    resolve(parsed);
+                } catch (e) {
+                    resolve(null);
+                }
             });
-        }
+        });
+    }
 
 
 
@@ -560,31 +626,91 @@ class HoloSphere {
      * @param {string} tableName - The table name to retrieve data from.
      * @returns {Promise<object|null>} - The parsed data from the table or null if not found.
      */
-    async getAllGlobal(tableName) {
-            return new Promise(async (resolve, reject) => {
-                let output = []
-                let counter = 0
-                this.gun.get(tableName.toString()).once((data, key) => {
-                    if (data) {
-                        const maplenght = Object.keys(data).length - 1
-                        this.gun.get(tableName.toString()).map().once(async (itemdata, key) => {
-                            counter += 1
-                            if (itemdata) {
-                                let parsed = await this.parse(itemdata)
+    // async getAllGlobal(tableName) {
+    //     return new Promise(async (resolve, reject) => {
+    //         let output = []
+    //         let counter = 0
+    //         this.gun.get(this.appname).get(tableName.toString()).once((data, key) => {
+    //             if (data) {
+    //                 const maplenght = Object.keys(data).length - 1
+    //                 this.gun.get(this.appname).get(tableName.toString()).map().once(async (itemdata, key) => {
+                     
+    //                     counter += 1
+    //                     if (itemdata) {
+    //                         let parsed = await this.parse(itemdata)
+    //                         output.push(parsed);
+    //                         console.log('getAllGlobal: parsed: ', parsed)
+    //                     }
+
+    //                     if (counter == maplenght) {
+    //                         resolve(output);
+                            
+    //                     }
+    //                 }
+    //                 );
+    //             } else resolve(output)
+    //         })
+    //     }
+    //     )
+    // }
+    async getAllGlobal(lens) {
+        if ( !lens) {
+            console.error('getAll: Missing required parameters:', { lens });
+            return [];
+        }
+
+        const schema = await this.getSchema(lens);
+        if (!schema && this.strict) {
+            console.error('getAll: Schema required in strict mode for lens:', lens);
+            return [];
+        }
+
+        return new Promise((resolve) => {
+            let output = [];
+            let counter = 0;
+
+            this.gun.get(this.appname).get(lens).once((data, key) => {
+                if (!data) {
+                    resolve(output);
+                    return;
+                }
+
+                const mapLength = Object.keys(data).length - 1;
+
+                this.gun.get(this.appname).get(lens).map().once(async (itemdata, key) => {
+                    counter += 1;
+                    if (itemdata) {
+                        try {
+                            const parsed = await this.parse(itemdata);
+                            if (schema) {
+                                const valid = this.validator.validate(schema, parsed);
+                                if (valid) {
+                                    output.push(parsed);
+                                } else if (this.strict) {
+                                    console.warn('Invalid data removed:', key, this.validator.errors);
+                                    await this.delete(holon, lens, key);
+                                } else {
+                                    console.warn('Invalid data found:', key, this.validator.errors);
+                                    output.push(parsed);
+                                }
+                            } else {
                                 output.push(parsed);
                             }
-
-                            if (counter == maplenght) {
-                                resolve(output);
+                        } catch (error) {
+                            console.error('Error parsing data:', error);
+                            if (this.strict) {
+                                await this.delete(holon, lens, key);
                             }
                         }
-                        );
-                    } else resolve(output)
-                })
-            }
-            )
-        }
+                    }
 
+                    if (counter === mapLength) {
+                        resolve(output);
+                    }
+                });
+            });
+        });
+    }
     /**
      * Deletes a specific key from a global table.
      * @param {string} tableName - The table name to delete from.
@@ -592,8 +718,8 @@ class HoloSphere {
      * @returns {Promise<void>}
      */
     async deleteGlobal(tableName, key) {
-            await this.gun.get(this.appname).get(tableName).get(key).put(null)
-        }
+        await this.gun.get(this.appname).get(tableName).get(key).put(null)
+    }
 
     /**
      * Deletes an entire global table.
@@ -601,16 +727,17 @@ class HoloSphere {
      * @returns {Promise<void>}
      */
     async deleteAllGlobal(tableName) {
-
-            return new Promise((resolve) => {
-                this.gun.get(this.appname).get(tableName).map().put(null).once(
-                    (data, key) => this.gun.get(this.appname).get(tableName).get(key).put(null)
-                )
-                this.gun.get(this.appname).get(tableName).put({}, ack => {
-                    resolve();
-                });
-            });
-        }
+       // return new Promise((resolve) => {
+            this.gun.get(this.appname).get(tableName).map().once( (data, key)=> {
+                this.gun.get(this.appname).get(tableName).get(key).put(null)
+            })
+            this.gun.get(this.appname).get(tableName).put(null, ack => {
+                console.log('deleteAllGlobal: ack: ', ack)
+            })
+            //    resolve();
+            //});
+        // });
+    }
 
     // ================================ COMPUTE FUNCTIONS ================================
     /**
@@ -621,8 +748,8 @@ class HoloSphere {
      */
     async compute(holon, lens, operation) {
 
-            let res = h3.getResolution(holon);
-            if(res < 1 || res > 15) return;
+        let res = h3.getResolution(holon);
+        if (res < 1 || res > 15) return;
         console.log(res)
         let parent = h3.cellToParent(holon, res - 1);
         let siblings = h3.cellToChildren(parent, res);
@@ -802,9 +929,10 @@ class HoloSphere {
      * @param {string} lens - The lens to subscribe to.
      * @param {function} callback - The callback to execute on changes.
      */
-    subscribe(holon, lens, callback) {
-        this.gun.get(this.appname).get(holon).get(lens).map().on((data, key) => {
-            callback(data, key)
+    async subscribe(holon, lens, callback) {
+        this.gun.get(this.appname).get(holon).get(lens).map().on(async (data, key) => {
+            if (data)
+            callback( await this.parse(data), key)
         })
     }
 }

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "holosphere",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "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",
+    "build": "",
+    "prepare": "npm run build"
   },
   "author": "Roberto Valenti",
   "license": "GPL-3.0-or-later",