holosphere 1.0.8 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "holosphere",
-  "version": "1.0.8",
+  "version": "1.1.0",
   "description": "Holonic Geospatial Communication Infrastructure",
   "main": "holosphere.js",
   "types": "holosphere.d.ts",

package/test/holosphere.test.js

@@ -12,14 +12,14 @@ describe('HoloSphere', () => {
     describe('Constructor', () => {
         test('should create instance with app name', () => {
             expect(holoSphere).toBeInstanceOf(HoloSphere);
-            expect(holoSphere.gunDb).toBeDefined();
+            expect(holoSphere.gun).toBeDefined();
             expect(holoSphere.validator).toBeDefined();
-            expect(holoSphere.aiClient).toBeUndefined();
+            expect(holoSphere.openai).toBeUndefined();
         });
 
         test('should initialize with OpenAI when key provided', () => {
-            const hsWithAI = new HoloSphere(testAppName, 'fake-key');
-            expect(hsWithAI.aiClient).toBeDefined();
+            const hsWithAI = new HoloSphere(testAppName, false, 'fake-key');
+            expect(hsWithAI.openai).toBeDefined();
         });
     });
 
@@ -34,132 +34,247 @@ describe('HoloSphere', () => {
             required: ['id', 'data']
         };
 
-        test('should set and get lens schema', async () => {
-            await holoSphere.setLensSchema(testLens, validSchema);
-            const result = await holoSphere.getLensSchema(testLens);
-            expect(result).toEqual(validSchema);
+        test('should set and get schema', async () => {
+            // Set the schema
+            const setResult = await holoSphere.setSchema(testLens, validSchema);
+            expect(setResult).toBe(true);
+
+            // Wait for GunDB to process
+            await new Promise(resolve => setTimeout(resolve, 100));
+
+            // Get and verify the schema
+            const retrievedSchema = await holoSphere.getSchema(testLens);
+            expect(retrievedSchema).toBeDefined();
+            expect(retrievedSchema).toEqual(validSchema);
+        }, 5000);
+
+        test('should handle invalid schema parameters', async () => {
+            const nullResult = await holoSphere.setSchema(null, null);
+            expect(nullResult).toBe(false);
+
+            const missingLensResult = await holoSphere.setSchema(undefined, validSchema);
+            expect(missingLensResult).toBe(false);
+
+            const missingSchemaResult = await holoSphere.setSchema(testLens, null);
+            expect(missingSchemaResult).toBe(false);
         });
 
-        test('should validate data against schema', async () => {
-            const validData = { id: 'test123', data: 'test data' };
-            const invalidData = { id: 123, data: ['wrong type'] };
+        test('should enforce strict mode schema validation', async () => {
+            const strictHoloSphere = new HoloSphere(testAppName, true);
+            
+            // Test cases for invalid schemas
+            const invalidSchemas = [
+                {
+                    // Missing type field
+                    properties: {
+                        id: { type: 'string' }
+                    }
+                },
+                {
+                    // Missing properties
+                    type: 'object'
+                },
+                {
+                    // Missing required fields
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string' }
+                    }
+                },
+                {
+                    // Invalid property type
+                    type: 'object',
+                    properties: {
+                        id: { type: 123 } // Should be string
+                    },
+                    required: ['id']
+                }
+            ];
+
+            // Test each invalid schema
+            for (const invalidSchema of invalidSchemas) {
+                const setResult = await strictHoloSphere.setSchema(testLens, invalidSchema);
+                expect(setResult).toBe(false);
+            }
 
-            await holoSphere.setLensSchema(testLens, validSchema);
+            // Valid schema should work in strict mode
+            const validSchema = {
+                type: 'object',
+                properties: {
+                    id: { type: 'string' },
+                    data: { type: 'string' }
+                },
+                required: ['id', 'data']
+            };
 
-            const validResult = holoSphere.validator.validate(validSchema, validData);
+            const validResult = await strictHoloSphere.setSchema(testLens, validSchema);
             expect(validResult).toBe(true);
 
-            const invalidResult = holoSphere.validator.validate(validSchema, invalidData);
-            expect(invalidResult).toBe(false);
+            // Verify schema was stored correctly
+            const retrievedSchema = await strictHoloSphere.getSchema(testLens);
+            expect(retrievedSchema).toEqual(validSchema);
+        }, 5000);
+
+        test('should handle schema retrieval for non-existent lens', async () => {
+            const result = await holoSphere.getSchema('nonexistent-lens');
+            expect(result).toBeNull();
+        });
+
+        afterEach(async () => {
+            // Clean up schemas after each test
+            await holoSphere.gun.get(holoSphere.appname)
+                .get(testLens)
+                .get('schema')
+                .put(null);
+            
+            // Wait for GunDB to process
+            await new Promise(resolve => setTimeout(resolve, 100));
         });
     });
 
     describe('Data Operations', () => {
-        const testHex = h3.latLngToCell(40.7128, -74.0060, 7);
+        const testHolon = h3.latLngToCell(40.7128, -74.0060, 7);
         const testLens = 'testLens';
-        const testContent = { id: '123', data: 'test' };
+        const validData = { id: 'test123', data: 'test data' };
+        const invalidData = { id: 'test456', wrongField: 'wrong data' };
 
-        test('should put and get hex data', async () => {
-            await holoSphere.putHexData(testHex, testLens, testContent);
-            const result = await holoSphere.getHexData(testHex, testLens);
-            expect(Array.isArray(result)).toBeTruthy();
-            expect(result.some(item => item.id === testContent.id)).toBeTruthy();
+        beforeEach(async () => {
+            // Set up schema for validation tests
+            const schema = {
+                type: 'object',
+                properties: {
+                    id: { type: 'string' },
+                    data: { type: 'string' }
+                },
+                required: ['id', 'data']
+            };
+            await holoSphere.setSchema(testLens, schema);
+        });
+
+        test('should put and get data with schema validation', async () => {
+            // Test valid data
+            const putResult = await holoSphere.put(testHolon, testLens, validData);
+            expect(putResult).toBe(true);
+
+            const getResult = await holoSphere.get(testHolon, testLens, validData.id);
+            expect(getResult).toEqual(validData);
+
+            // Test invalid data
+            const invalidPutResult = await holoSphere.put(testHolon, testLens, invalidData);
+            expect(invalidPutResult).toBe(false);
         }, 10000);
 
-        test('should get hex key', async () => {
-            await holoSphere.putHexData(testHex, testLens, testContent);
-            const result = await holoSphere.getHexKey(testHex, testLens, testContent.id);
-            expect(result).toBeDefined();
-            expect(result.id).toBe(testContent.id);
+        test('should get all data with schema validation', async () => {
+            await holoSphere.put(testHolon, testLens, validData);
+            await holoSphere.put(testHolon, testLens, { id: 'test789', data: 'more test data' });
+
+            const results = await holoSphere.getAll(testHolon, testLens);
+            expect(Array.isArray(results)).toBeTruthy();
+            expect(results.length).toBeGreaterThan(0);
+            expect(results.some(item => item.id === validData.id)).toBeTruthy();
         }, 10000);
 
-        test('should delete hex data', async () => {
-            await holoSphere.putHexData(testHex, testLens, testContent);
-            await holoSphere.deleteHexData(testHex, testLens, testContent.id);
-            const result = await holoSphere.getHexKey(testHex, testLens, testContent.id);
+        test('should delete data', async () => {
+            await holoSphere.put(testHolon, testLens, validData);
+            await holoSphere.delete(testHolon, testLens, validData.id);
+            
+            const result = await holoSphere.get(testHolon, testLens, validData.id);
             expect(result).toBeNull();
         }, 10000);
-    });
 
-    describe('Global Data Operations', () => {
-        const tableName = 'testTable';
-        const testData = { id: 'test1', value: 'testValue' };
+        test('should delete all data', async () => {
+            await holoSphere.put(testHolon, testLens, validData);
+            await holoSphere.put(testHolon, testLens, { id: 'test789', data: 'more test data' });
+            
+            const deleteResult = await holoSphere.deleteAll(testHolon, testLens);
+            expect(deleteResult).toBe(true);
+            
+            const results = await holoSphere.getAll(testHolon, testLens);
+            expect(results).toEqual([]);
+        }, 10000);
 
-        test('should put and get global data', async () => {
-            await holoSphere.putGlobalData(tableName, testData);
-            // Add delay to allow Gun to process
-            await new Promise(resolve => setTimeout(resolve, 1000));
+        test('should enforce strict mode data validation', async () => {
+            const strictHoloSphere = new HoloSphere(testAppName, true);
             
-            const result = await holoSphere.getGlobalData(tableName);
-            expect(result).toBeDefined();
-            if (result) {
-                expect(result.id).toBe(testData.id);
-            }
-        }, 15000);
+            // Define schema for strict mode tests
+            const strictSchema = {
+                type: 'object',
+                properties: {
+                    id: { type: 'string' },
+                    data: { type: 'string' }
+                },
+                required: ['id', 'data']
+            };
+            
+            // Set up schema
+            await strictHoloSphere.setSchema(testLens, strictSchema);
+            
+            // Try to put data without schema in strict mode
+            const noSchemaResult = await strictHoloSphere.put(testHolon, 'no-schema-lens', validData);
+            expect(noSchemaResult).toBe(false);
+            
+            // Try to get data without schema in strict mode
+            const noSchemaData = await strictHoloSphere.getAll(testHolon, 'no-schema-lens');
+            expect(noSchemaData).toEqual([]);
+            
+            // Invalid data should be removed in strict mode
+            await strictHoloSphere.put(testHolon, testLens, invalidData);
+            const results = await strictHoloSphere.getAll(testHolon, testLens);
+            expect(results.some(item => item.id === invalidData.id)).toBe(false);
+        }, 10000);
+    });
+
+    describe('Node Operations', () => {
+        const testHolon = h3.latLngToCell(40.7128, -74.0060, 7);
+        const testLens = 'testLens';
+        const testNode = { value: 'test node data' };
 
-        test('should get global data key', async () => {
-            await holoSphere.putGlobalData(tableName, testData);
-            // Add delay to allow Gun to process
-            await new Promise(resolve => setTimeout(resolve, 1000));
+        test('should put and get node', async () => {
+            await holoSphere.putNode(testHolon, testLens, testNode);
+            
+            // Wait for GunDB to process
+            await new Promise(resolve => setTimeout(resolve, 100));
             
-            const result = await holoSphere.getGlobalDataKey(tableName, testData.id);
+            const result = await holoSphere.getNode(testHolon, testLens, 'value');
             expect(result).toBeDefined();
-            if (result) {
-                expect(result.id).toBe(testData.id);
-            }
-        }, 15000);
+            expect(result).toBe('test node data');
+        }, 10000);
 
-        test('should delete global data', async () => {
-            await holoSphere.putGlobalData(tableName, testData);
-            // Add delay to allow Gun to process
-            await new Promise(resolve => setTimeout(resolve, 1000));
+        test('should delete node', async () => {
+            // First put the node
+            await holoSphere.putNode(testHolon, testLens, testNode);
+            await new Promise(resolve => setTimeout(resolve, 100));
             
-            await holoSphere.deleteGlobalData(tableName);
-            // Add delay to allow Gun to process
-            await new Promise(resolve => setTimeout(resolve, 1000));
+            // Verify node exists
+            const beforeDelete = await holoSphere.getNode(testHolon, testLens, 'value');
+            expect(beforeDelete).toBe('test node data');
             
-            const result = await holoSphere.getGlobalData(tableName);
-            expect(result).toBeNull();
-        }, 15000);
-
-        afterEach(async () => {
-            // Clean up after each test
-            await holoSphere.deleteGlobalData(tableName);
-            await new Promise(resolve => setTimeout(resolve, 1000));
-        });
-    });
+            // Delete the node
+            const deleteResult = await holoSphere.deleteNode(testHolon, testLens, 'value');
+            expect(deleteResult).toBe(true);
+            
+            // Wait for deletion to process
+            await new Promise(resolve => setTimeout(resolve, 100));
+            
+            // Verify node is deleted
+            const afterDelete = await holoSphere.getNode(testHolon, testLens, 'value');
+            expect(afterDelete).toBeNull();
+        }, 10000);
 
-    describe('Encryption Operations', () => {
-        const testSecret = 'secret123';
-        const testData = { message: 'secret message' };
+        test('should handle invalid node operations', async () => {
+            // Test missing parameters
+            const nullResult = await holoSphere.deleteNode(null, null, null);
+            expect(nullResult).toBe(false);
 
-        test('should encrypt and decrypt data', async () => {
-            const encrypted = await holoSphere.encrypt(testData, testSecret);
-            expect(encrypted).toBeDefined();
-            
-            const decrypted = await holoSphere.decrypt(encrypted, testSecret);
-            expect(decrypted).toEqual(testData);
+            const nullGet = await holoSphere.getNode(null, null, null);
+            expect(nullGet).toBeNull();
         });
 
-        test('should handle encrypted hex data', async () => {
-            const testHex = h3.latLngToCell(40.7128, -74.0060, 7);
-            const testLens = 'testLens';
-            const testContent = { id: 'test123', data: 'secret data' };
-
-            // Create and login test user
-            try {
-                await holoSphere.createUser('testuser', 'testpass');
-                await holoSphere.login('testuser', 'testpass');
-            } catch (error) {
-                console.log('User already exists or login failed');
-            }
-
-            await holoSphere.putHexData(testHex, testLens, testContent, true, testSecret);
-            const result = await holoSphere.getHexData(testHex, testLens, testSecret);
-            
-            expect(Array.isArray(result)).toBeTruthy();
-            await holoSphere.logout();
-        }, 15000);
+        afterEach(async () => {
+            // Clean up after each test
+            await holoSphere.deleteNode(testHolon, testLens, 'value');
+            await new Promise(resolve => setTimeout(resolve, 100));
+        });
     });
 
     describe('Geospatial Operations', () => {
@@ -167,21 +282,21 @@ describe('HoloSphere', () => {
         const lng = -74.0060;
         const resolution = 7;
 
-        test('should get hex from coordinates', async () => {
-            const hex = await holoSphere.getHex(lat, lng, resolution);
-            expect(hex).toBeDefined();
-            expect(typeof hex).toBe('string');
+        test('should get holon from coordinates', async () => {
+            const holon = await holoSphere.getHolon(lat, lng, resolution);
+            expect(holon).toBeDefined();
+            expect(typeof holon).toBe('string');
         });
 
         test('should get scalespace from coordinates', () => {
             const scales = holoSphere.getScalespace(lat, lng);
             expect(Array.isArray(scales)).toBeTruthy();
-            expect(scales.length).toBe(15);
+            expect(scales.length).toBe(15); // 0-14 resolution levels
         });
 
-        test('should get hex scalespace', () => {
-            const hex = h3.latLngToCell(lat, lng, resolution);
-            const scales = holoSphere.getHexScalespace(hex);
+        test('should get holon scalespace', () => {
+            const holon = h3.latLngToCell(lat, lng, resolution);
+            const scales = holoSphere.getHolonScalespace(holon);
             expect(Array.isArray(scales)).toBeTruthy();
             expect(scales.length).toBe(resolution + 1);
         });
@@ -190,8 +305,8 @@ describe('HoloSphere', () => {
     afterAll(async () => {
         // Clean up test data
         const testLens = 'testLens';
-        const testHex = h3.latLngToCell(40.7128, -74.0060, 7);
-        await holoSphere.clearlens(testHex, testLens);
+        const testHolon = h3.latLngToCell(40.7128, -74.0060, 7);
+        await holoSphere.deleteAll(testHolon, testLens);
         
         // Allow time for Gun to process
         await new Promise(resolve => setTimeout(resolve, 1000));