divhunt 2.0.0

package/addons/core/clients/back/http/item/functions/gRPC/create.js

@@ -0,0 +1,192 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import * as grpc from '@grpc/grpc-js'
+import * as protoLoader from '@grpc/proto-loader'
+import { fileURLToPath } from 'url'
+import { dirname, join } from 'path'
+
+import divhunt from '#framework/load.js';
+import clients from '#clients/addon.js';
+
+clients.Fn('item.grpc.create', function(item)
+{
+    const { host, port, timeout } = item.Get(['host', 'port', 'timeout']);
+    
+    if(item.Get('instance'))
+    {
+        item.Get('onError') && item.Get('onError')('gRPC Client already created.');
+        return;
+    }
+    
+    this.methods.init = () =>
+    {
+        const protoPath = join(dirname(fileURLToPath(import.meta.url)), '/../../../service.proto');
+        
+        const definition = protoLoader.loadSync(protoPath, 
+        {
+            keepCase: true,
+            longs: String,
+            enums: String,
+            defaults: true,
+            oneofs: true
+        });
+
+        const universalPackage = grpc.loadPackageDefinition(definition).universal;
+        
+        const address = `${host}:${port}`;
+        
+        const client = new universalPackage.UniversalService(address, grpc.credentials.createInsecure(), 
+        {
+            'grpc.max_send_message_length': 1024 * 1024 * 100,
+            'grpc.max_receive_message_length': 1024 * 1024 * 100,
+            'grpc.keepalive_time_ms': 30000,
+            'grpc.keepalive_timeout_ms': 10000,
+            'grpc.keepalive_permit_without_calls': 1,
+            'grpc.http2.min_time_between_pings_ms': 10000,
+            'grpc.http2.max_pings_without_data': 0
+        });
+        
+        const wrapper = {
+            instance: client,
+            execute: this.methods.execute,
+            ping: this.methods.ping
+        };
+        
+        item.Set('instance', wrapper);
+        
+        if(item.Get('onConnect'))
+        {
+            item.Get('onConnect')(wrapper);
+        }
+        
+        divhunt.Emit('clients.grpc.connect', wrapper);
+    };
+    
+    this.methods.execute = async (functionName, data = {}, requestTimeout = timeout) =>
+    {
+        const client = item.Get('instance');
+        
+        if(!client)
+        {
+            throw new Error('gRPC Client not initialized.');
+        }
+        
+        const grpc = {
+            id: item.Get('id'),
+            client,
+            function: functionName,
+            data,
+            items: {},
+            variables: {},
+            duration: performance.now(),
+            response: {
+                data: null,
+                message: 'Request not sent.',
+                code: 0
+            }
+        };
+        
+        try
+        {
+            divhunt.Emit('clients.grpc.request.before', grpc);
+            await divhunt.Middleware('clients.grpc.request.before', grpc);
+            
+            if(item.Get('onRequest'))
+            {
+                await Promise.resolve(item.Get('onRequest')(grpc));
+            }
+            
+            const response = await new Promise((resolve, reject) => 
+            {
+                const deadline = new Date(Date.now() + requestTimeout * 1000);
+                
+                try
+                {
+                    client.instance.execute({function: functionName, data: JSON.stringify(grpc.data)}, {deadline}, (error, response) => 
+                    {
+                        if(error) 
+                        {
+                            return reject(error);
+                        }
+
+                        try
+                        {
+                            const data = JSON.parse(response.data);
+                            
+                            resolve({
+                                data, 
+                                code: response.code, 
+                                message: response.message
+                            });
+                        }
+                        catch(error)
+                        {
+                            return reject(new Error('Expected valid JSON from response'));
+                        }
+                    });
+                }
+                catch(error)
+                {
+                    reject(new Error('Failed to execute function "' + functionName + '"'));
+                }
+            });
+            
+            grpc.response = response;
+            
+            divhunt.Emit('clients.grpc.request.after', grpc);
+            await divhunt.Middleware('clients.grpc.request.after', grpc);
+            
+            if(item.Get('onResponse'))
+            {
+                item.Get('onResponse')(grpc);
+            }
+            
+            grpc.duration = (performance.now() - grpc.duration).toFixed(2);
+            
+            const result = {
+                data: grpc.response.data,
+                code: grpc.response.code,
+                message: grpc.response.message,
+                duration: grpc.duration
+            };
+            
+            if(item.Get('onComplete'))
+            {
+                item.Get('onComplete')(result, grpc);
+            }
+            
+            return result;
+        }
+        catch(error)
+        {
+            grpc.error = error.message || 'Request failed';
+            grpc.duration = (performance.now() - grpc.duration).toFixed(2);
+            
+            if(item.Get('onError'))
+            {
+                item.Get('onError')(grpc.error, grpc);
+            }
+            
+            throw new Error(grpc.error);
+        }
+    };
+    
+    this.methods.ping = async (requestTimeout = 3) =>
+    {
+        try
+        {
+            const response = await this.methods.execute('ping', {}, requestTimeout);
+            return response.data.pong === true;
+        }
+        catch(error)
+        {
+            if(item.Get('onError'))
+            {
+                item.Get('onError')('Ping failed: ' + error.message);
+            }
+            return false;
+        }
+    };
+    
+    this.methods.init();
+});

package/addons/core/clients/back/http/item/functions/gRPC/execute.js

@@ -0,0 +1,15 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import clients from '#clients/addon.js';
+
+clients.Fn('item.grpc.execute', function(item, name, data = {}, requestTimeout)
+{
+    const instance = item.Get('instance');
+    
+    if(!instance || !instance.execute)
+    {
+        throw new Error('gRPC Client not initialized properly.');
+    }
+    
+    return instance.execute(name, data, requestTimeout || item.Get('timeout'));
+});

package/addons/core/clients/back/http/item/functions/http/create.js

@@ -0,0 +1,143 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import divhunt from '#framework/load.js';
+import clients from '#clients/addon.js';
+
+clients.Fn('item.http.create', function(item)
+{
+    const { host, port, timeout } = item.Get(['host', 'port', 'timeout']);
+    
+    if(item.Get('instance'))
+    {
+        item.Get('onError') && item.Get('onError')('HTTP Client already created.');
+        return;
+    }
+    
+    this.methods.init = () =>
+    {
+        const baseUrl = `http://${host}:${port}`;
+        
+        const client = {
+            baseUrl,
+            request: this.methods.request
+        };
+        
+        item.Set('instance', client);
+        
+        if(item.Get('onConnect'))
+        {
+            item.Get('onConnect')(client);
+        }
+        
+        divhunt.Emit('clients.http.connect', client);
+    };
+    
+    this.methods.request = async (path, method = 'GET', data = {}, requestTimeout = timeout) =>
+    {
+        const client = item.Get('instance');
+        
+        if(!client)
+        {
+            throw new Error('HTTP Client not initialized.');
+        }
+        
+        const http = {
+            id: item.Get('id'),
+            client,
+            path,
+            method,
+            data,
+            url: `${client.baseUrl}${path}`,
+            items: {},
+            variables: {},
+            duration: performance.now(),
+            response: {
+                data: null,
+                message: 'Request not sent.',
+                code: 0
+            }
+        };
+
+        try
+        {
+            divhunt.Emit('clients.http.request.before', http);
+            await divhunt.Middleware('clients.http.request.before', http);
+            
+            if(item.Get('onRequest'))
+            {
+                await Promise.resolve(item.Get('onRequest')(http));
+            }
+            
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), requestTimeout * 1000);
+            
+            const options = {
+                method: http.method,
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                signal: controller.signal
+            };
+            
+            if(http.method !== 'GET' && http.data)
+            {
+                options.body = JSON.stringify(http.data);
+            }
+            
+            const response = await fetch(http.url, options);
+            clearTimeout(timeoutId);
+            
+            http.response.code = response.status;
+            http.response.message = response.statusText;
+            
+            const contentType = response.headers.get('content-type');
+            
+            if(contentType && contentType.includes('application/json'))
+            {
+                http.response.data = await response.json();
+            }
+            else
+            {
+                http.response.data = await response.text();
+            }
+            
+            divhunt.Emit('clients.http.request.after', http);
+            await divhunt.Middleware('clients.http.request.after', http);
+            
+            if(item.Get('onResponse'))
+            {
+                item.Get('onResponse')(http);
+            }
+            
+            http.duration = (performance.now() - http.duration).toFixed(2);
+            
+            const result = {
+                data: http.response.data,
+                code: http.response.code,
+                message: http.response.message,
+                duration: http.duration
+            };
+            
+            if(item.Get('onComplete'))
+            {
+                item.Get('onComplete')(result, http);
+            }
+            
+            return result;
+        }
+        catch(error)
+        {
+            http.error = error.message || 'Request failed';
+            http.duration = (performance.now() - http.duration).toFixed(2);
+            
+            if(item.Get('onError'))
+            {
+                item.Get('onError')(http.error, http);
+            }
+            
+            throw new Error(http.error);
+        }
+    };
+    
+    this.methods.init();
+});

package/addons/core/clients/back/http/item/functions/http/delete.js

@@ -0,0 +1,8 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import clients from '#clients/addon.js';
+
+clients.Fn('item.http.delete', function(item, path, data = {}, requestTimeout)
+{
+    return item.Fn('http.request', path, 'DELETE', data, requestTimeout);
+});

package/addons/core/clients/back/http/item/functions/http/get.js

@@ -0,0 +1,8 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import clients from '#clients/addon.js';
+
+clients.Fn('item.http.get', function(item, path, data = {}, requestTimeout)
+{
+    return item.Fn('http.request', path, 'GET', data, requestTimeout);
+});

package/addons/core/clients/back/http/item/functions/http/post.js

@@ -0,0 +1,8 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import clients from '#clients/addon.js';
+
+clients.Fn('item.http.post', function(item, path, data = {}, requestTimeout)
+{
+    return item.Fn('http.request', path, 'POST', data, requestTimeout);
+});

package/addons/core/clients/back/http/item/functions/http/put.js

@@ -0,0 +1,8 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import clients from '#clients/addon.js';
+
+clients.Fn('item.http.put', function(item, path, data = {}, requestTimeout)
+{
+    return item.Fn('http.request', path, 'PUT', data, requestTimeout);
+});

package/addons/core/clients/back/http/item/functions/http/request.js

@@ -0,0 +1,15 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import clients from '#clients/addon.js';
+
+clients.Fn('item.http.request', function(item, path, method = 'GET', data = {}, requestTimeout)
+{
+    const instance = item.Get('instance');
+    
+    if(!instance || !instance.request)
+    {
+        throw new Error('HTTP Client not initialized properly.');
+    }
+    
+    return instance.request(path, method, data, requestTimeout || item.Get('timeout'));
+});

package/addons/core/clients/back/http/load.js

@@ -0,0 +1,17 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import clients from '#clients/addon.js';
+
+import '#clients/item/catch/add.js';
+
+import '#clients/item/functions/http/create.js';
+import '#clients/item/functions/http/request.js';
+import '#clients/item/functions/http/get.js';
+import '#clients/item/functions/http/post.js';
+import '#clients/item/functions/http/put.js';
+import '#clients/item/functions/http/delete.js';
+
+import '#clients/item/functions/gRPC/create.js';
+import '#clients/item/functions/gRPC/execute.js';
+
+export default clients;

package/addons/core/commands/LICENSE.txt

@@ -0,0 +1,40 @@
+Copyright © 2025 Divhunt GmbH
+
+This License governs use of the Divhunt framework (the "Software"). By accessing or using the Software, you agree to be bound by the terms of this License.
+
+1. GRANT OF LICENSE  
+   You are granted a limited, non-exclusive, non-transferable, non-sublicensable license to use the Software solely for:
+   - personal projects;
+   - internal business purposes;
+   - client work, provided the client is not reselling or redistributing the Software.
+
+2. ATTRIBUTION AND BRANDING  
+   a. All uses of the Software must retain visible attribution to “Divhunt”.  
+   b. You must not remove, obscure, alter, or suppress any branding, notices, or credits related to Divhunt.  
+   c. Any public project using the Software must clearly state that it uses the “Divhunt Framework”.
+
+3. PROHIBITED USES  
+   The following are strictly prohibited:  
+   a. Rebranding, renaming, or representing the Software as your own work;  
+   b. Creating derivative frameworks or similar software tools based on the Software with the intent of distribution;  
+   c. Redistributing, sublicensing, or selling the Software or any modified version thereof;  
+   d. Using the Software in any commercial product, service, or offering without explicit, written permission from Divhunt GmbH.
+
+4. MODIFICATIONS  
+   You may modify the Software for personal or internal use only. Modified versions may not be:  
+   - redistributed;  
+   - rebranded or marketed as original work;  
+   - offered as a service or product.
+
+5. ENFORCEMENT AND TERMINATION  
+   Any violation of this License will result in the immediate termination of all rights granted herein. Divhunt GmbH reserves the right to pursue legal remedies including but not limited to damages, injunctions, and recovery of profits obtained through unauthorized use.
+
+6. NO WARRANTY  
+   THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. IN NO EVENT SHALL JOVANAT GMBH BE LIABLE FOR ANY DAMAGES ARISING FROM THE USE OR INABILITY TO USE THE SOFTWARE.
+
+7. GOVERNING LAW  
+   This License shall be governed by and construed in accordance with the laws of Switzerland. All disputes shall be subject to the exclusive jurisdiction of the courts of Zug, Switzerland.
+
+---
+
+For commercial licensing or other questions, please contact: **dejan@divhunt.com**