divhunt 2.0.0

package/addons/core/servers/back/grpc/item/functions/start.js

@@ -0,0 +1,65 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import { fileURLToPath } from 'url'
+import { dirname, join } from 'path'
+
+import divhunt from '#framework/load.js';
+import serversGRPC from '#servers/grpc/addon.js';
+
+serversGRPC.Fn('item.start', async function(item)
+{
+    if(item.Get('instance'))
+    {
+        return;
+    }
+
+    try
+    {
+        const grpcModule = await import('@grpc/grpc-js');
+        const protoLoaderModule = await import('@grpc/proto-loader');
+
+        const grpc = grpcModule.default || grpcModule;
+        const protoLoader = protoLoaderModule.default || protoLoaderModule;
+
+        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 server = new grpc.Server({
+            'grpc.max_send_message_length': 1024 * 1024 * 100,
+            'grpc.max_receive_message_length': 1024 * 1024 * 100
+        });
+        
+        server.addService(universalPackage.UniversalService.service, 
+        {
+            stream: (...data) => item.Fn('stream', ...data)
+        });
+        
+        server.bindAsync(`${item.Get('host')}:${item.Get('port')}`, grpc.ServerCredentials.createInsecure(), (error) => 
+        {
+            if(error) 
+            {
+                item.Get('onError') && item.Get('onError').call(item, error.message);
+                return;
+            }
+            
+            item.Set('instance', server);
+            item.Get('onStart') && item.Get('onStart').call(item, server);
+            
+            divhunt.Emit('servers.grpc.start', server);
+        });
+    }
+    catch(error)
+    {
+        item.Get('onError') && item.Get('onError').call(item, error.message);
+    }
+});

package/addons/core/servers/back/grpc/item/functions/stream.js

@@ -0,0 +1,68 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import divhunt from '#framework/load.js';
+import serversGRPC from '#servers/grpc/addon.js';
+
+serversGRPC.Fn('item.stream', function(item, stream)
+{
+    stream.id = divhunt.GenerateUID();
+
+    stream.request = function(name, data, onChunk = null, id = null)
+    {
+        id = id || divhunt.GenerateUID();
+
+        const extracted = divhunt.BinariesExtract(data);
+
+        stream.write({
+            data: JSON.stringify({type: 'request', name, data: extracted.data, id}),
+            binaries: extracted.binaries
+        });
+
+        item.Get('onStreamRequest') && item.Get('onStreamRequest').call(item, stream, {type: 'request', name, data, binaries: extracted.binaries, id});
+
+        return item.Fn('resolve', id, null, onChunk);
+    };
+
+    stream.respond = function(data, message, code, end = true, id = null)
+    {
+        id = id || divhunt.GenerateUID();
+
+        const extracted = divhunt.BinariesExtract(data);
+
+        stream.write({
+            data: JSON.stringify({type: 'respond', data: extracted.data, message, code, id, end}),
+            binaries: extracted.binaries
+        });
+
+        item.Get('onStreamRespond') && item.Get('onStreamRespond').call(item, stream, {type: 'respond', data, binaries: extracted.binaries, message, code, end, id});
+    };
+
+    stream.on('data', (response) =>
+    {
+        const payload = JSON.parse(response.data);
+
+        if(payload.data && response.binaries)
+        {
+            payload.data = divhunt.BinariesInject(payload.data, response.binaries);
+        }
+
+        if(payload.type === 'respond')
+        {
+            item.Fn('resolve', payload.id, payload);
+        }
+
+        item.Get('onStreamData') && item.Get('onStreamData').call(item, stream, payload);
+    });
+
+    stream.on('error', (error) => 
+    {
+        item.Get('onStreamError') && item.Get('onStreamError').call(item, stream, error.message);
+    });
+
+    stream.on('close', () => 
+    {
+        item.Get('onStreamEnd') && item.Get('onStreamEnd').call(item, stream);
+    });
+
+    item.Get('onStreamConnect') && item.Get('onStreamConnect').call(item, stream);
+});

package/addons/core/servers/back/grpc/load.js

@@ -0,0 +1,9 @@
+import serversGRPC from '#servers/grpc/addon.js';
+
+import '#servers/grpc/item/catch/add.js';
+
+import '#servers/grpc/item/functions/start.js';
+import '#servers/grpc/item/functions/stream.js';
+import '#servers/grpc/item/functions/resolve.js';
+
+export default serversGRPC;

package/addons/core/servers/back/grpc/service.proto

@@ -0,0 +1,20 @@
+syntax = "proto3";
+
+package universal;
+
+service UniversalService 
+{
+    rpc Stream (stream Request) returns (stream Response);
+}
+
+message Request
+{
+    string data = 1;
+    map<string, bytes> binaries = 2;
+}
+
+message Response
+{
+    string data = 1;
+    map<string, bytes> binaries = 2;
+}

package/addons/core/servers/back/http/addon.js

@@ -0,0 +1,15 @@
+import divhunt from '#framework/load.js';
+
+const serversHTTP = divhunt.Addon('servers.http', (addon) =>
+{
+    addon.Field('id', ['string']);
+    addon.Field('instance', ['object']);
+    addon.Field('port', ['number', 3000]);
+
+    addon.Field('onStart', ['function']);
+    addon.Field('onRequest', ['function']);
+    addon.Field('onError', ['function']);
+    addon.Field('onComplete', ['function']);
+});
+
+export default serversHTTP;

package/addons/core/servers/back/http/functions/extract/data.js

@@ -0,0 +1,232 @@
+import { json } from 'node:stream/consumers';
+import serversHTTP from '#servers/http/addon.js';
+import Busboy from 'busboy';
+
+serversHTTP.Fn('extract.data', async function(request)
+{
+    this.methods = {};
+
+    this.methods.extractQueryParams = (request) =>
+    {
+        const properties = {};
+        const url = new URL(request.url, `https://${request.headers.host}`);
+
+        url.searchParams.forEach((value, key) =>
+        {
+            properties[key] = value;
+        });
+
+        return properties;
+    };
+
+    this.methods.extractMultipart = async (request) =>
+    {
+        const properties = {};
+
+        await new Promise((resolve, reject) =>
+        {
+            const busboy = Busboy({headers: request.headers});
+
+            busboy.on('field', (name, value) =>
+            {
+                properties[name] = value;
+            });
+
+            busboy.on('file', (name, stream) =>
+            {
+                const chunks = [];
+
+                stream.on('data', (chunk) =>
+                {
+                    chunks.push(chunk);
+                });
+
+                stream.on('end', () =>
+                {
+                    properties[name] = Buffer.concat(chunks);
+                });
+            });
+
+            busboy.on('finish', resolve);
+            busboy.on('error', reject);
+
+            request.pipe(busboy);
+        });
+
+        return properties;
+    };
+
+    this.methods.extractJson = async (request) =>
+    {
+        try
+        {
+            const body = await json(request);
+
+            if (body && typeof body === 'object')
+            {
+                return body;
+            }
+        }
+        catch(error)
+        {
+            // Invalid JSON, skip body parsing
+        }
+
+        return {};
+    };
+
+    this.methods.convertNumber = (value) =>
+    {
+        const num = Number(value);
+        return isNaN(num) ? null : num;
+    };
+
+    this.methods.convertString = (value) =>
+    {
+        return String(value);
+    };
+
+    this.methods.convertBoolean = (value) =>
+    {
+        if (['true', '1', true, 1].includes(value))
+        {
+            return true;
+        }
+
+        if (['false', '0', false, 0].includes(value))
+        {
+            return false;
+        }
+
+        return null;
+    };
+
+    this.methods.convertArray = (value) =>
+    {
+        if (Array.isArray(value))
+        {
+            return value;
+        }
+
+        if (typeof value === 'string')
+        {
+            try
+            {
+                const parsed = JSON.parse(value);
+                return Array.isArray(parsed) ? parsed : value.split(',').map(item => item.trim()).filter(Boolean);
+            }
+            catch
+            {
+                return value.split(',').map(item => item.trim()).filter(Boolean);
+            }
+        }
+
+        return null;
+    };
+
+    this.methods.convertObject = (value) =>
+    {
+        if (typeof value === 'object' && !Array.isArray(value))
+        {
+            return value;
+        }
+
+        if (typeof value === 'string')
+        {
+            try
+            {
+                const parsed = JSON.parse(value);
+                return (typeof parsed === 'object' && !Array.isArray(parsed)) ? parsed : null;
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        return null;
+    };
+
+    this.methods.convertBinary = (value) =>
+    {
+        if (Buffer.isBuffer(value))
+        {
+            return value;
+        }
+
+        if (typeof value === 'string')
+        {
+            try
+            {
+                return Buffer.from(value, 'base64');
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        return null;
+    };
+
+    this.methods.convertValue = (value, hint, base) =>
+    {
+        if (!hint)
+        {
+            return {[base]: value};
+        }
+
+        if (value === null || value === undefined || value === '')
+        {
+            return {[base]: null};
+        }
+
+        const converters =
+        {
+            number: this.methods.convertNumber,
+            string: this.methods.convertString,
+            boolean: this.methods.convertBoolean,
+            array: this.methods.convertArray,
+            object: this.methods.convertObject,
+            binary: this.methods.convertBinary
+        };
+
+        const converter = converters[hint.toLowerCase()];
+
+        if (converter)
+        {
+            return {[base]: converter(value)};
+        }
+
+        return {[base]: value};
+    };
+
+    const properties = this.methods.extractQueryParams(request);
+
+    if (request.method !== 'GET')
+    {
+        const contentType = request.headers['content-type'] || '';
+
+        if (contentType.includes('multipart/form-data'))
+        {
+            const multipart = await this.methods.extractMultipart(request);
+            Object.assign(properties, multipart);
+        }
+        else
+        {
+            const body = await this.methods.extractJson(request);
+            Object.assign(properties, body);
+        }
+    }
+
+    const result = {};
+
+    for (const [key, value] of Object.entries(properties))
+    {
+        const [base, hint] = key.split(':');
+        const converted = this.methods.convertValue(value, hint, hint ? base : key);
+        Object.assign(result, converted);
+    }
+
+    return result;
+});

package/addons/core/servers/back/http/item/catch/add.js

@@ -0,0 +1,6 @@
+import serversHTTP from '#servers/http/addon.js';
+
+serversHTTP.ItemOn('add', function(item)
+{
+    item.Fn('start');
+});

package/addons/core/servers/back/http/item/functions/start.js

@@ -0,0 +1,135 @@
+import http from 'http';
+import serversHTTP from '#servers/http/addon.js';
+import divhunt from '#framework/load.js';
+
+serversHTTP.Fn('item.start', function(item)
+{
+    if(item.Get('instance'))
+    {
+        item.Get('onError') && item.Get('onError')('HTTP Server already started.');
+        return;
+    }
+
+    this.methods.types = {
+        JSON: { contentType: 'application/json', formatter: content => JSON.stringify(content) },
+        HTML: { contentType: 'text/html', formatter: content => String(content) },
+        CSS:  { contentType: 'text/css', formatter: content => String(content) },
+        JS:   { contentType: 'application/javascript', formatter: content => String(content) }
+    };
+
+    this.methods.createHttpObject = async (request, response) =>
+    {
+        return {
+            id: divhunt.GenerateUID(),
+            request,
+            data: await serversHTTP.Fn('extract.data', request),
+            url: new URL(request.url, `http://${request.headers.host}`),
+            user: this.methods.user(request),
+            time: performance.now(),
+            error: null,
+            raw: response,
+            streaming: false,
+            types: this.methods.types,
+            prevent: false,
+            response: {
+                type: 'JSON',
+                data: null,
+                message: 'Request processed',
+                code: 200
+            }
+        };
+    };
+
+    this.methods.user = (request) => 
+    {
+        const forwarded = request.headers['x-forwarded-for'];
+        const agent = request.headers['user-agent'] || null;
+        const referrer = request.headers['referer'] || null;
+
+        const ip = (typeof forwarded === 'string' && forwarded.length) ? forwarded.split(',')[0].trim() : request.socket?.remoteAddress;
+
+        return {
+            ip,
+            agent,
+            forwarded: forwarded || null,
+            referrer
+        };
+
+    };
+
+    this.methods.respond = (http, response) =>
+    {
+        if(http.prevent)
+        {
+            return;
+        }
+
+        const type = http.types[http.response.type] || http.types.JSON;
+
+        http.time = (performance.now() - http.time).toFixed(2);
+
+        if(http.error)
+        {
+            response.writeHead(500, { 'Content-Type': 'application/json' });
+            response.end(JSON.stringify({
+                data: {},
+                message: http.error,
+                code: 500,
+                time: http.time
+            }));
+            
+            return;
+        }
+
+        const content = http.response.type === 'JSON' ? {
+            data: http.response.data || {},
+            message: http.response.message || 'No response message provided.',
+            code: http.response.code,
+            time: http.time
+        } : http.response.data || '';
+
+        response.writeHead(http.response.code, { 'Content-Type': type.contentType });
+        response.end(type.formatter(content));
+
+        item.Get('onComplete') && item.Get('onComplete')(http);
+    };
+
+    this.methods.init = () => 
+    {
+        const httpServer = http.createServer(async (request, response) =>
+        {
+            const http = await this.methods.createHttpObject(request, response);
+
+            try
+            {
+                if(item.Get('onRequest'))
+                {
+                    await Promise.resolve(item.Get('onRequest')(http));
+                }
+
+                this.methods.respond(http, response);
+            }
+            catch(error)
+            {
+                http.error = error.message || 'Internal server error';
+
+                item.Get('onError') && item.Get('onError')(http.error);
+
+                this.methods.respond(http, response);
+            }
+        });
+        
+        httpServer.on('error', (error) =>
+        {
+            item.Get('onError') && item.Get('onError')(error.message);
+        });
+        
+        httpServer.listen(item.Get('port'), () =>
+        {
+            item.Set('instance', httpServer);
+            item.Get('onStart') && item.Get('onStart')(httpServer);
+        });
+    };
+
+    this.methods.init();
+});

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

@@ -0,0 +1,8 @@
+import serversHTTP from '#servers/http/addon.js';
+
+import '#servers/http/functions/extract/data.js';
+
+import '#servers/http/item/catch/add.js';
+import '#servers/http/item/functions/start.js';
+
+export default serversHTTP;

package/addons/float/modals/front/css/modals.css

@@ -0,0 +1,26 @@
+.dh-modal
+{
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.dh-modal > .backdrop
+{
+    position: absolute;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+}
+
+.dh-modal > .content
+{
+    position: relative;
+    z-index: 1;
+}

package/addons/float/modals/front/js/#register/addon.js

@@ -0,0 +1,10 @@
+const modals = divhunt.Addon('modals', (addon) =>
+{
+    addon.Field('id', ['string']);
+    addon.Field('backdrop', ['number', 0.5]);
+    addon.Field('closeable', ['boolean', true]);
+    addon.Field('escape', ['boolean', true]);
+    addon.Field('render', ['function', null]);
+    addon.Field('onOpen', ['function', null]);
+    addon.Field('onClose', ['function', null]);
+});

package/addons/float/modals/front/js/item/catch/add.js

@@ -0,0 +1,48 @@
+modals.ItemOn('add', (item) =>
+{
+    const overlays = divhunt.Addon('overlays');
+    const id = item.Get('id');
+
+    const overlay = overlays.Item({
+        id: 'modal-' + id,
+        backdrop: item.Get('backdrop'),
+        closeable: item.Get('closeable'),
+        escape: item.Get('escape'),
+        render: item.Get('render'),
+        onOpen: (overlay) =>
+        {
+            const element = overlay.Get('element');
+
+            if(element)
+            {
+                element.classList.add('dh-modal');
+
+                const content = element.querySelector('.content');
+
+                if(content)
+                {
+                    content.style.left = '';
+                    content.style.top = '';
+                }
+            }
+
+            const onOpen = item.Get('onOpen');
+
+            if(typeof onOpen === 'function')
+            {
+                onOpen(item);
+            }
+        },
+        onClose: () =>
+        {
+            const onClose = item.Get('onClose');
+
+            if(typeof onClose === 'function')
+            {
+                onClose(item);
+            }
+        }
+    });
+
+    item.Set('overlay', overlay);
+});

package/addons/float/modals/front/js/item/catch/remove.js

@@ -0,0 +1,9 @@
+modals.ItemOn('remove', (item) =>
+{
+    const overlay = item.Get('overlay');
+
+    if(overlay)
+    {
+        overlay.Remove();
+    }
+});

package/addons/float/overlays/front/css/overlays.css

@@ -0,0 +1,29 @@
+.dh-overlay
+{
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    pointer-events: none;
+    z-index: 100000;
+}
+
+.dh-overlay > .backdrop
+{
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background: #000;
+    pointer-events: auto;
+}
+
+.dh-overlay > .content
+{
+    position: absolute;
+    width: fit-content;
+    max-width: 100%;
+    pointer-events: auto;
+}