holosphere 1.0.8 → 1.1.1

package/holosphere.js

@@ -3,26 +3,30 @@ 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.
      * @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, openaikey = null) {
-        this.validator = new Ajv2019({ allErrors: false, strict: false });
+    constructor(appname, strict = false, openaikey = null) {
+        this.appname = appname
+        this.strict = strict;
+        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);
             //     return content;}
         });
 
-        this.gun = this.gun.get(appname)
-        this.users = {}; // Initialize users
-        this.holonagonVotes = {}; // Initialize holonagonVotes
-
         if (openaikey != null) {
             this.openai = new OpenAI({
                 apiKey: openaikey,
@@ -30,6 +34,8 @@ class HoloSphere {
         }
     }
 
+    // ================================ SCHEMA FUNCTIONS ================================
+
     /**
      * Sets the JSON schema for a specific lens.
      * @param {string} lens - The lens identifier.
@@ -37,16 +43,84 @@ class HoloSphere {
      * @returns {Promise} - Resolves when the schema is set.
      */
     async setSchema(lens, schema) {
-        return new Promise((resolve, reject) => {
-            this.gun.get(lens).get('schema').put(JSON.stringify(schema), ack => {
-                if (ack.err) {
-                    resolve(new Error('Failed to add schema: ' + ack.err));
-                } else {
-                    console.log('Schema added successfully under lens:', lens);
-                    resolve(ack);
+        if (!lens || !schema) {
+            console.error('setSchema: Missing required parameters');
+            return false;
+        }
+
+        // Basic schema validation - check for required fields
+        if (!schema.type || typeof schema.type !== 'string') {
+            console.error('setSchema: Schema must have a type field');
+            return false;
+        }
+
+        if (this.strict) {
+            try {
+                // Validate schema against JSON Schema meta-schema
+                const metaSchema = {
+                    type: 'object',
+                    required: ['type', 'properties'],
+                    properties: {
+                        type: { type: 'string' },
+                        properties: {
+                            type: 'object',
+                            additionalProperties: {
+                                type: 'object',
+                                required: ['type'],
+                                properties: {
+                                    type: { type: 'string' }
+                                }
+                            }
+                        },
+                        required: {
+                            type: 'array',
+                            items: { type: 'string' }
+                        }
+                    }
+                };
+
+                const valid = this.validator.validate(metaSchema, schema);
+                if (!valid) {
+                    console.error('setSchema: Invalid schema structure:', this.validator.errors);
+                    return false;
                 }
-            })
-        })
+
+                // Additional strict mode checks
+                if (!schema.properties || typeof schema.properties !== 'object') {
+                    console.error('setSchema: Schema must have properties in strict mode');
+                    return false;
+                }
+
+                if (!schema.required || !Array.isArray(schema.required) || schema.required.length === 0) {
+                    console.error('setSchema: Schema must have required fields in strict mode');
+                    return false;
+                }
+            } catch (error) {
+                console.error('setSchema: Schema validation error:', error);
+                return false;
+            }
+        }
+
+        return new Promise((resolve) => {
+            try {
+                const schemaString = JSON.stringify(schema);
+                this.gun.get(this.appname)
+                    .get(lens)
+                    .get('schema')
+                    .put(schemaString, ack => {
+                        if (ack.err) {
+                            console.error('Failed to add schema:', ack.err);
+                            resolve(false);
+                        } else {
+                            console.log('Schema added successfully for lens:', lens);
+                            resolve(true);
+                        }
+                    });
+            } catch (error) {
+                console.error('setSchema: Error stringifying schema:', error);
+                resolve(false);
+            }
+        });
     }
 
     /**
@@ -55,236 +129,455 @@ class HoloSphere {
      * @returns {Promise<object|null>} - The retrieved schema or null if not found.
      */
     async getSchema(lens) {
+        if (!lens) {
+            console.error('getSchema: Missing lens parameter');
+            return null;
+        }
+
         return new Promise((resolve) => {
-            this.gun.get(lens).get('schema').once(data => {
-                if (data) {
-                    let parsed;
-                    try {
-                        parsed = JSON.parse(data);
+            this.gun.get(this.appname)
+                .get(lens)
+                .get('schema')
+                .once(data => {
+                    if (!data) {
+                        resolve(null);
+                        return;
                     }
-                    catch (e) {
-                        resolve(null)
+
+                    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":'));
+                            if (schemaStr) {
+                                resolve(JSON.parse(schemaStr));
+                            } else {
+                                resolve(null);
+                            }
+                        } else {
+                            resolve(null);
+                        }
+                    } catch (error) {
+                        console.error('getSchema: Error parsing schema:', error);
+                        resolve(null);
                     }
-                    resolve(parsed);
-                } else {
-                    resolve(null);
-                }
-            })
-        })
-    }
-    /**
-     * Deletes a specific tag from a given ID.
-     * @param {string} id - The identifier from which to delete the tag.
-     * @param {string} tag - The tag to delete.
-     */
-    async delete(id, tag) {
-        await this.gun.get(id).get(tag).put(null)
+                });
+        });
     }
 
+    // ================================ CONTENT FUNCTIONS ================================
+
     /**
      * Stores content in the specified holon and lens.
      * @param {string} holon - The holon identifier.
      * @param {string} lens - The lens under which to store the content.
-     * @param {object} content - The content to store.
+     * @param {object} data - The data to store.
+     * @returns {Promise<boolean>} - Returns true if successful, false if there was an error
      */
-    async put(holon, lens, content) {
-        if (!holon || !lens || !content) return;
-        console.error('Error in put:', holon, lens, content);
-        // Retrieve the schema for the lens
-        let schema = await this.getSchema(lens)
+    async put(holon, lens, data) {
+        if (!holon || !lens || !data) {
+            console.error('put: Missing required parameters:', { holon, lens, data });
+            return false;
+        }
+
+        if (!data.id) {
+            console.error('put: Data must have an id field');
+            return false;
+        }
+
+        // Strict validation of schema and data
+        const schema = await this.getSchema(lens);
         if (schema) {
-            // Validate the content against the schema
-            const valid = this.validator.validate(schema, content);
-            if (!valid) {
-                console.error('Not committing invalid content:', this.validator.errors);
-                return null;
+            try {
+                const valid = this.validator.validate(schema, data);
+                if (!valid) {
+                    const errors = this.validator.errors;
+                    console.error('put: Schema validation failed:', errors);
+                    return false;
+                }
+            } catch (error) {
+                console.error('put: Schema validation error:', error);
+                return false;
             }
+        } else if (this.strict) {
+            console.error('put: Schema required in strict mode for lens:', lens);
+            return false;
         }
 
-        // Create a node for the content
-        const payload = JSON.stringify(content);
+        return new Promise((resolve) => {
+            try {
+                const payload = JSON.stringify(data);
+
+                this.gun.get(this.appname)
+                    .get(holon)
+                    .get(lens)
+                    .get(data.id)
+                    .put(payload, ack => {
+                        if (ack.err) {
+                            console.error("Error adding data to GunDB:", ack.err);
+                            resolve(false);
+                        } else {
+                            resolve(true);
+                        }
+                    });
+            } catch (error) {
+                console.error('Error in put operation:', error);
+                resolve(false);
+            }
+        });
+    }
 
-        let noderef;
+    /**
+     * Retrieves content from the specified holon and lens.
+     * @param {string} holon - The holon identifier.
+     * @param {string} lens - The lens from which to retrieve content.
+     * @returns {Promise<Array<object>>} - The retrieved content.
+     */
+    async getAll(holon, lens) {
+        if (!holon || !lens) {
+            console.error('getAll: Missing required parameters:', { holon, lens });
+            return [];
+        }
 
-        if (content.id) { //use the user-defined id. Important to be able to send updates using put
-            noderef = this.gun.get(lens).get(content.id).put(payload)
-            this.gun.get(holon.toString()).get(lens).get(content.id).put(payload)
-        } else { // create a content-addressable reference like IPFS. Note: no updates possible using put
-            const hashBuffer = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(payload));
-            const hashArray = Array.from(new Uint8Array(hashBuffer));
-            const hashholon = hashArray.map(byte => byte.toString(16).padStart(2, "0")).join("");
-            noderef = this.gun.get(lens).get(hashholon).put(payload)
-            this.gun.get(holon.toString()).get(lens).get(hashholon).put(payload)
+        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;
 
-    async putNode(holon, lens, node) {
-        this.gun.get(holon).get(lens).set(node)
+            this.gun.get(this.appname).get(holon).get(lens).once((data, key) => {
+                if (!data) {
+                    resolve(output);
+                    return;
+                }
+
+                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 = 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);
+                            }
+                        } catch (error) {
+                            console.error('Error parsing data:', error);
+                            if (this.strict) {
+                                await this.delete(holon, lens, key);
+                            }
+                        }
+                    }
+
+                    if (counter === mapLength) {
+                        resolve(output);
+                    }
+                });
+            });
+        });
     }
 
-    async parse(data) {
-        let parsed = {};
+    /**
+   * 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 data === 'object' && data !== null) {
-            if (data._ && 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 query = data._['#'].split('/');
-                let holon = query[1];
-                let lens = query[2];
-                let key = query[3];
-                parsed = await this.getKey(holon, lens, key);
-            } else if (data._ && data._['>']) {
-                // This might be a gun node, try to get its value
-                const nodeValue = Object.values(data).find(v => typeof v !== 'object' && v !== '_');
+                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 {
-                        parsed = JSON.parse(nodeValue);
+                        parsedData = JSON.parse(nodeValue);
                     } catch (e) {
                         console.log('Invalid JSON in node value:', nodeValue);
-                        parsed = nodeValue; // return the raw data
+                        parsedData = nodeValue; // return the raw data
                     }
                 } else {
-                    console.log('Unable to parse gun node:', data);
-                    parsed = data; // return the original data
+                    console.log('Unable to parse GunDB node:', rawData);
+                    parsedData = rawData; // return the original data
                 }
             } else {
-                // Treat it as regular data
-                parsed = data;
+                // 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 {
-                parsed = JSON.parse(data);
+                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('Invalid JSON:', data);
-                parsed = data; // return the raw data
+                console.log('Failed to parse, returning raw data', e);
+                parsedData = rawData; // return the raw data
             }
         }
 
-        return parsed;
+        return parsedData;
     }
 
     /**
-     * Retrieves content from the specified holon and lens.
+     * Retrieves a specific key from the specified holon and lens.
      * @param {string} holon - The holon identifier.
-     * @param {string} lens - The lens from which to retrieve content.
-     * @returns {Promise<Array<object>>} - The retrieved content.
+     * @param {string} lens - The lens from which to retrieve the key.
+     * @param {string} key - The specific key to retrieve.
+     * @returns {Promise<object|null>} - The retrieved content or null if not found.
      */
-    async get(holon, lens) {
-        if (!holon || !lens) {
-            console.log('Wrong get:', holon, lens)
-            return;
-        }
-        // Wrap the gun operation in a promise
-        //retrieve lens schema
-        const schema = await this.getSchema(lens);
-
-        if (!schema) {
-            console.log('The schema for "' + lens + '" is not defined');
-            // return null; // No schema found, return null if strict about it 
+    async get(holon, lens, key) {
+        if (!holon || !lens || !key) {
+            console.error('get: Missing required parameters:', { holon, lens, key });
+            return null;
         }
 
-        return new Promise(async (resolve, reject) => {
-            let output = []
-            let counter = 0
-            this.gun.get(holon.toString()).get(lens).once((data, key) => {
-                if (data) {
-                    const maplenght = Object.keys(data).length - 1
-                    console.log('Map length:', maplenght)
-                    this.gun.get(holon.toString()).get(lens).map().once(async (itemdata, key) => {
-                        counter += 1
-                        if (itemdata) {
-                            let parsed = await this.parse (itemdata)
-                          
+        // Get schema for validation
+        const schema = await this.getSchema(lens);
 
-                            if (schema) {
-                                let valid = this.validator.validate(schema, parsed);
-                                if (!valid || parsed == null || parsed == undefined) {
-                                    console.log('Removing Invalid content:', this.validator.errors);
-                                    this.gun.get(holon).get(lens).get(key).put(null);
+        return new Promise((resolve) => {
+            let timeout = setTimeout(() => {
+                console.warn('get: Operation timed out');
+                resolve(null);
+            }, 5000); // 5 second timeout
+
+            this.gun.get(this.appname)
+                .get(holon)
+                .get(lens)
+                .get(key)
+                .once((data,key) => {
+                    clearTimeout(timeout);
+                   
+                    if (!data) {
+                        resolve(null);
+                        return;
+                    }
 
-                                } else {
-                                    output.push(parsed);
+                    try {
+                        const parsed = this.parse(data);
+
+                        // Validate against schema if one exists
+                        if (schema) {
+                            const valid = this.validator.validate(schema, parsed);
+                            if (!valid) {
+                                console.error('get: Invalid data according to schema:', this.validator.errors);
+                                if (this.strict) {
+                                    resolve(null);
+                                    return;
                                 }
                             }
-                            else {
-                                output.push(parsed);
-                            }
-                        }
-
-                        if (counter == maplenght) {
-                            resolve(output);
                         }
+                        resolve(parsed);
+                    } catch (error) {
+                        console.error('Error parsing data:', error);
+                        resolve(null);
                     }
-                    );
-                } else resolve(output)
-            })
+                });
+        });
+    }
+
+    /**
+     * Deletes a specific key from a given holon and lens.
+     * @param {string} holon - The holon identifier.
+     * @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);
+                }
+            });
+        });
+    }
+
+    /**
+     * Deletes all keys from a given holon and lens.
+     * @param {string} holon - The holon identifier.
+     * @param {string} lens - The lens from which to delete all keys.
+     * @returns {Promise<boolean>} - Returns true if successful, false if there was an error
+     */
+    async deleteAll(holon, lens) {
+        if (!holon || !lens) {
+            console.error('deleteAll: Missing holon or lens parameter');
+            return false;
         }
-        );
+
+        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) {
+                    resolve(true); // Nothing to delete
+                    return;
+                }
+
+                // 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(
+                        new Promise((resolveDelete) => {
+                            this.gun.get(this.appname).get(holon).get(lens).get(key).put(null, ack => {
+                                resolveDelete(!!ack.ok); // Convert to boolean
+                            });
+                        })
+                    );
+                });
+
+                // Wait for all deletions to complete
+                Promise.all(deletionPromises)
+                    .then(results => {
+                        const allSuccessful = results.every(result => result === true);
+                        resolve(allSuccessful);
+                    })
+                    .catch(error => {
+                        console.error('Error in deleteAll:', error);
+                        resolve(false);
+                    });
+            });
+        });
     }
 
-       /**
-     * Retrieves a specific key from the specified holon and lens.
+    // ================================ NODE FUNCTIONS ================================
+
+
+    /**
+     * Stores a specific gun node in a given holon and lens.
      * @param {string} holon - The holon identifier.
-     * @param {string} lens - The lens from which to retrieve the key.
-     * @param {string} key - The specific key to retrieve.
-     * @returns {Promise<object|null>} - The retrieved content or null if not found.
+     * @param {string} lens - The lens under which to store the node.
+     * @param {object} node - The node to store.
      */
-       async getKey(holon, lens, key) {
+    async putNode(holon, lens, node) {
         return new Promise((resolve) => {
-            // Use Gun to get the data
-            this.gun.get(holon).get(lens).get(key).once((data, key) => {
-                if (data) {
-                    console.log('Data getting parsed:', data)
-                    try {
-                        let parsed = JSON.parse(data); // Resolve the promise with the data if data is found
-                        resolve(parsed);
-                    }
-                    catch (e) {
-                        resolve(data)
-                    }
-                   
+            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(null); // Reject the promise if no data is found
+                    resolve(true);
                 }
             });
         });
-
     }
 
     /**
    * Retrieves a specific gun node from the specified holon and lens.
    * @param {string} holon - The holon identifier.
-   * @param {string} lens - The lens from which to retrieve the key.
+   * @param {string} lens - The lens identifier.
    * @param {string} key - The specific key to retrieve.
-   * @returns {Promise<object|null>} - The retrieved content or null if not found.
+   * @returns {Promise<object|null>} - The retrieved node or null if not found.
    */
-     getNode(holon, lens, key) {
-        // Use Gun to get the data
-        return this.gun.get(holon).get(lens).get(key)
+    getNode(holon, lens, key) {
+        if (!holon || !lens || !key) {
+            console.error('getNode: Missing required parameters');
+            return null;
+        }
+
+        return this.gun.get(this.appname)
+            .get(holon)
+            .get(lens)
+            .get(key)
+
     }
 
-    //GLOBAL FUNCTIONS
-    async deleteNode(nodeId, tag) {
-        await this.gun.get(nodeId).get(tag).put(null)
+    getNodeRef(soul) {
+        const parts = soul.split('/');
+        let ref = this.gun.get(this.appname);
+        parts.forEach(part => {
+            ref = ref.get(part);
+        });
+        return ref;
     }
+
+    /**
+     * Deletes a specific gun node from a given holon and lens.
+     * @param {string} holon - The holon identifier.
+     * @param {string} lens - The lens identifier.
+     * @param {string} key - The key of the node to delete.
+     * @returns {Promise<boolean>} - Returns true if successful
+     */
+    async deleteNode(holon, lens, key) {
+        if (!holon || !lens || !key) {
+            console.error('deleteNode: Missing required parameters');
+            return false;
+        }
+
+        return new Promise((resolve) => {
+            this.gun.get(this.appname)
+                .get(holon)
+                .get(lens)
+                .get(key)
+                .put(null, ack => {
+                    if (ack.err) {
+                        console.error('deleteNode: Error deleting node:', ack.err);
+                        resolve(false);
+                    } else {
+                        resolve(true);
+                    }
+                });
+        });
+    }
+
     // ================================ GLOBAL FUNCTIONS ================================
     /**
      * Stores data in a global (non-holon-specific) table.
-     * @param {string} table - The table name to store data in.
+     * @param {string} tableName - The table name to store data in.
      * @param {object} data - The data to store. If it has an 'id' field, it will be used as the key.
      * @returns {Promise<void>}
      */
     async putGlobal(tableName, data) {
+
         return new Promise((resolve, reject) => {
             if (!tableName || !data) {
                 reject(new Error('Table name and data are required'));
                 return;
             }
 
+
             if (data.id) {
-                this.gun.get(tableName).get(data.id).put(JSON.stringify(data), ack => {
+                this.gun.get(this.appname).get(tableName).get(data.id).put(JSON.stringify(data), ack => {
                     if (ack.err) {
                         reject(new Error(ack.err));
                     } else {
@@ -292,7 +585,7 @@ class HoloSphere {
                     }
                 });
             } else {
-                this.gun.get(tableName).put(JSON.stringify(data), ack => {
+                this.gun.get(this.appname).get(tableName).put(JSON.stringify(data), ack => {
                     if (ack.err) {
                         reject(new Error(ack.err));
                     } else {
@@ -303,21 +596,21 @@ class HoloSphere {
         });
     }
 
-     /**
-     * Retrieves a specific key from a global table.
-     * @param {string} tableName - The table name to retrieve from.
-     * @param {string} key - The key to retrieve.
-     * @returns {Promise<object|null>} - The parsed data for the key or null if not found.
-     */
-     async getGlobal(tableName, key) {
+    /**
+    * Retrieves a specific key from a global table.
+    * @param {string} tableName - The table name to retrieve from.
+    * @param {string} key - The key to retrieve.
+    * @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(tableName).get(key).once((data) => {
+            this.gun.get(this.appname).get(tableName).get(key).once((data) => {
                 if (!data) {
                     resolve(null);
                     return;
                 }
                 try {
-                    const parsed = JSON.parse(data);
+                    const parsed = this.parse(data);
                     resolve(parsed);
                 } catch (e) {
                     resolve(null);
@@ -326,43 +619,124 @@ class HoloSphere {
         });
     }
 
+
+
     /**
      * Retrieves all data from a global table.
      * @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) {
+    // 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) => {
-            this.gun.get(tableName).once((data) => {
+            let output = [];
+            let counter = 0;
+
+            this.gun.get(this.appname).get(lens).once((data, key) => {
                 if (!data) {
-                    resolve(null);
+                    resolve(output);
                     return;
                 }
-                try {
-                    const parsed = JSON.parse(data);
-                    resolve(parsed);
-                } catch (e) {
-                    resolve(null);
-                }
+
+                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);
+                            }
+                        } catch (error) {
+                            console.error('Error parsing data:', error);
+                            if (this.strict) {
+                                await this.delete(holon, lens, key);
+                            }
+                        }
+                    }
+
+                    if (counter === mapLength) {
+                        resolve(output);
+                    }
+                });
             });
         });
     }
-
-   
+    /**
+     * Deletes a specific key from a global table.
+     * @param {string} tableName - The table name to delete from.
+     * @param {string} key - The key to delete.
+     * @returns {Promise<void>}
+     */
+    async deleteGlobal(tableName, key) {
+        await this.gun.get(this.appname).get(tableName).get(key).put(null)
+    }
 
     /**
      * Deletes an entire global table.
-     * @param {string} table - The table name to delete.
+     * @param {string} tableName - The table name to delete.
      * @returns {Promise<void>}
      */
     async deleteAllGlobal(tableName) {
-   
-        return new Promise((resolve) => {
-            this.gun.get(tableName).map().put(null)
-            this.gun.get(tableName).put(null, 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 ================================
@@ -391,7 +765,7 @@ class HoloSphere {
                     resolve(); // Resolve the promise to prevent it from hanging
                 }, 1000); // Timeout of 5 seconds
 
-                this.gun.get(siblings[i]).get(lens).map().once((data, key) => {
+                this.gun.get(this.appname).get(siblings[i]).get(lens).map().once((data, key) => {
                     clearTimeout(timeout); // Clear the timeout if data is received
                     if (data) {
                         content.push(data.content);
@@ -405,7 +779,7 @@ class HoloSphere {
         console.log('Content:', content);
         let computed = await this.summarize(content.join('\n'))
         console.log('Computed:', computed)
-        let node = await this.gun.get(parent + '_summary').put({ id: parent + '_summary', content: computed })
+        let node = await this.gun.get(this.appname).get(parent + '_summary').put({ id: parent + '_summary', content: computed })
 
         this.put(parent, lens, node);
         this.compute(parent, lens, operation)
@@ -420,10 +794,10 @@ class HoloSphere {
         let entities = {};
 
         // Get list out of Gun
-        this.gun.get(holon).get(lens).map().once((data, key) => {
+        this.gun.get(this.appname).get(holon).get(lens).map().once((data, key) => {
             //entities = data;
             //const id = Object.keys(entities)[0] // since this would be in object form, you can manipulate it as you would like. 
-            this.gun.get(holon).get(lens).put({ [key]: null })
+            this.gun.get(this.appname).get(holon).get(lens).put({ [key]: null })
         })
     }
 
@@ -555,92 +929,12 @@ 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(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)
         })
     }
-
-    // ================================ GOVERNANCE FUNCTIONS ================================
-    /**
-     * Retrieves the final vote for a user, considering delegations.
-     * @param {string} userId - The user's identifier.
-     * @param {string} topic - The voting topic.
-     * @param {object} votes - The current votes.
-     * @param {Set<string>} [visited=new Set()] - Set of visited users to prevent cycles.
-     * @returns {string|null} - The final vote or null if not found.
-     */
-    getFinalVote(userId, topic, votes, visited = new Set()) {
-        if (this.users[userId]) { // Added this.users
-            if (visited.has(userId)) {
-                return null; // Avoid circular delegations
-            }
-            visited.add(userId);
-
-            const delegation = this.users[userId].delegations[topic];
-            if (delegation && votes[delegation] === undefined) {
-                return this.getFinalVote(delegation, topic, votes, visited); // Prefixed with this
-            }
-
-            return votes[userId] !== undefined ? votes[userId] : null;
-        }
-        return null;
-    }
-
-    /**
-     * Aggregates votes for a specific holon and topic.
-     * @param {string} holonId - The holon identifier.
-     * @param {string} topic - The voting topic.
-     * @returns {object} - Aggregated vote counts.
-     */
-    aggregateVotes(holonId, topic) {
-        if (!this.holonagonVotes[holonId] || !this.holonagonVotes[holonId][topic]) {
-            return {}; // Handle undefined votes
-        }
-        const votes = this.holonagonVotes[holonId][topic];
-        const aggregatedVotes = {};
-
-        Object.keys(votes).forEach(userId => {
-            const finalVote = this.getFinalVote(userId, topic, votes); // Prefixed with this
-            if (finalVote !== null) {
-                aggregatedVotes[finalVote] = (aggregatedVotes[finalVote] || 0) + 1;
-            }
-        });
-
-        return aggregatedVotes;
-    }
-
-    /**
-     * Delegates a user's vote to another user.
-     * @param {string} userId - The user's identifier.
-     * @param {string} topic - The voting topic.
-     * @param {string} delegateTo - The user to delegate the vote to.
-     */
-    async delegateVote(userId, topic, delegateTo) {
-        const response = await fetch('/delegate', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ userId, topic, delegateTo })
-        });
-        alert(await response.text());
-    }
-
-    /**
-     * Casts a vote for a user on a specific topic and holon.
-     * @param {string} userId - The user's identifier.
-     * @param {string} holonId - The holon identifier.
-     * @param {string} topic - The voting topic.
-     * @param {string} vote - The vote choice.
-     */
-    async vote(userId, holonId, topic, vote) {
-        const response = await fetch('/vote', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ userId, holonId, topic, vote })
-        });
-        alert(await response.text());
-    }
-
 }
 
 export default HoloSphere;