divhunt 2.0.0

package/addons/core/commands/back/item/functions/run.js

@@ -0,0 +1,82 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import divhunt from '#framework/load.js';
+import commands from '../../addon.js';
+
+commands.Fn('item.run', function(item, properties = {}, onChunk = null, context = {})
+{
+    const startTime = performance.now();
+
+    return new Promise(async (resolve, reject) =>
+    {
+        if(!item.Get('in'))
+        {
+            properties = {};
+        }
+
+        const callback = (data, message = "Command '{{command}}' executed successfully.", code = 200, end = true) =>
+        {
+            if(message === null && code === 404)
+            {
+                message = 'The requested resource cannot be found.';
+            }
+
+            if(code >= 200 && code < 300 && item.Get('out'))
+            {
+                try
+                {
+                    data = divhunt.DataDefine(data, item.Get('out'));
+                }
+                catch(error)
+                {
+                    throw new Error('Command OUT Error. ' + error.message);
+                }
+            }
+
+            const result = {
+                data,
+                message: message?.replace('{{command}}', item.Get('id')),
+                code,
+                time: (performance.now() - startTime).toFixed(2),
+                end
+            };
+
+            if(onChunk && !result.end)
+            {
+                onChunk(result);
+            }
+
+            if(result.end)
+            {
+                resolve(result);
+            }
+        };
+     
+        try
+        {
+            if(item.Get('in'))
+            {
+                try 
+                {
+                    properties = divhunt.DataDefine(properties, item.Get('in'));
+                }
+                catch(error)
+                {
+                    return resolve({
+                        data: error.message, 
+                        message: 'Request contains invalid parameters.', 
+                        code: 400,
+                        time: (performance.now() - startTime).toFixed(2),
+                        end: true
+                    });
+                }
+            }
+
+            await item.Get('callback').call(context, properties, callback);
+        }
+        catch(error)
+        {
+            reject(error);
+        }
+    })
+});

package/addons/core/commands/back/items/many.js

@@ -0,0 +1,76 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import divhunt from '#framework/load.js';
+import commands from '../addon.js';
+
+commands.Item({
+    id: 'commands:get:many',
+    exposed: true,
+    method: 'GET',
+    endpoint: '/api/commands',
+    type: 'JSON',
+    out: {
+        commands: {
+            type: 'array',
+            each: {
+                type: 'object',
+                config: {
+                    id: ['string'],
+                    exposed: ['boolean'],
+                    meta: {
+                        type: 'object',
+                        config: {
+                            description: ['string']
+                        }
+                    },
+                    data: {
+                        type: 'object',
+                        config: {
+                            in: ['object'],
+                            out: ['object'],
+                        }
+                    },
+                    api: {
+                        type: 'object',
+                        config: {
+                            type: ['string'],
+                            method: ['string'],
+                            endpoint: ['string']
+                        }
+                    }
+                }
+            }
+        }
+    },
+    callback: async function(properties, resolve)
+    {
+        const list = [];
+
+        Object.values(commands.Items()).forEach((item) => 
+        {
+            if(!item.Get('exposed'))
+            {
+                return true;
+            }
+
+            list.push({
+                id: item.Get('id'),
+                exposed: item.Get('exposed'),
+                meta: {
+                    description: item.Get('description'),
+                },
+                data: {
+                    in: (item.Get('in') ? divhunt.DataConfig(item.Get('in')) : null),
+                    out: (item.Get('out') ? divhunt.DataConfig(item.Get('out')) : null)
+                },
+                api: {
+                    type: item.Get('type'),
+                    method: item.Get('method'),
+                    endpoint: item.Get('endpoint')
+                }
+            });
+        });
+
+        resolve({commands: list});
+    }
+});

package/addons/core/commands/back/items/one.js

@@ -0,0 +1,78 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import divhunt from '#framework/load.js';
+import commands from '../addon.js';
+
+commands.Item({
+    id: 'commands:get:one',
+    exposed: true,
+    method: 'GET',
+    endpoint: '/api/commands/:id',
+    type: 'JSON',
+    in: {
+        id: ['string']
+    },
+    out: {
+        command: {
+            type: 'object',
+            config: {
+                id: ['string'],
+                exposed: ['boolean'],
+                meta: {
+                    type: 'object',
+                    config: {
+                        description: ['string']
+                    }
+                },
+                data: {
+                    type: 'object',
+                    config: {
+                        in: ['object'],
+                        out: ['object'],
+                    }
+                },
+                api: {
+                    type: 'object',
+                    config: {
+                        type: ['string'],
+                        method: ['string'],
+                        endpoint: ['string']
+                    }
+                }
+            }
+        }
+    },
+    callback: async function(properties, resolve)
+    {
+        const command = commands.ItemGet(properties.id);
+
+        if(!command)
+        {
+            return resolve(null, 'Command does not exist.', 404);
+        }
+
+        if(!command.Get('exposed'))
+        {
+            return resolve(null, 'Command is not exposed.', 403);
+        }
+
+        resolve({
+            command: {
+                id: command.Get('id'),
+                exposed: command.Get('exposed'),
+                meta: {
+                    description: command.Get('description'),
+                },
+                data: {
+                    in: command.Get('in') ? divhunt.DataConfig(command.Get('in')) : null,
+                    out: command.Get('out') ? divhunt.DataConfig(command.Get('out')) : null
+                },
+                api: {
+                    type: command.Get('type'),
+                    method: command.Get('method'),
+                    endpoint: command.Get('endpoint')
+                }
+            }
+        });
+    }
+});

package/addons/core/commands/back/items/run.js

@@ -0,0 +1,51 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import commands from '../addon.js';
+
+commands.Item({
+    id: 'commands:run',
+    exposed: true,
+    method: 'POST',
+    endpoint: '/api/commands/run',
+    type: 'JSON',
+    in: {
+        id: ['string', null, true],
+        data: ['object']
+    },
+    out: {
+        data: ['string|object|boolean|number|array'],
+        message: ['string'],
+        code: ['number']
+    },
+    callback: async function(properties, resolve)
+    {
+        console.log(properties.id);
+        
+        const command = commands.ItemGet(properties.id);
+
+        if(!command)
+        {
+            return resolve(null, 'Command does not exist.', 404);
+        }
+
+        if(!command.Get('exposed'))
+        {
+            return resolve(null, 'Command is not exposed.', 403);
+        }
+
+        try 
+        {
+            const result = await commands.Item(properties.id).Fn('run', (properties.data || {}));
+
+            resolve({
+                data: result.data,
+                message: result.message,
+                code: result.code
+            });
+        }
+        catch(error)
+        {
+            resolve(null, error.message, 500);
+        }
+    }
+});

package/addons/core/commands/back/load.js

@@ -0,0 +1,20 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import commands from './addon.js';
+
+import './functions/find.js';
+import './item/functions/run.js';
+
+/* gRPC */
+import './functions/grpc/server.js';
+import './functions/grpc/client.js';
+
+/* HTTP */
+import './functions/http/server.js';
+
+/* Items */
+import './items/one.js';
+import './items/many.js';
+import './items/run.js';
+
+export default commands;

package/addons/core/commands/front/#register/addon.js

@@ -0,0 +1,11 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const commands = divhunt.Addon('commands', (addon) =>
+{
+    addon.Field('id', ['string']);
+    addon.Field('type', ['string', 'JSON']);
+    addon.Field('description', ['string']);
+    addon.Field('in', ['object|string']);
+    addon.Field('out', ['object|string']);
+    addon.Field('callback', ['function']);
+});

package/addons/core/commands/front/functions/find.js

@@ -0,0 +1,24 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+commands.Fn('find', function(method, pathname)
+{
+    const items = Object.values(this.Items());
+
+    for (const item of items)
+    {
+        if (item.Get('method') !== method)
+        {
+            continue;
+        }
+
+        const endpoint = item.Get('endpoint');
+        const result = divhunt.RouteMatch(endpoint, pathname);
+
+        if (result.match)
+        {
+            return item;
+        }
+    }
+
+    return null;
+});

package/addons/core/commands/front/item/functions/run.js

@@ -0,0 +1,98 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+commands.Fn('item.run', function(item, properties = {}, context = {})
+{
+    this.methods.resolve = null;
+    this.methods.reject = null;
+
+    this.methods.init = async (resolve, reject) => 
+    {
+        this.methods.resolve = resolve;
+        this.methods.reject = reject;
+        
+        if(item.Get('in'))
+        {
+            try 
+            {
+                properties = divhunt.DataDefine(properties, item.Get('in'));
+            }
+            catch(error)
+            {
+                return this.methods.resolve({data: error.message, message: 'Request contains invalid parameters.', code: 400});
+            }
+        }
+
+        if(item.Get('callback'))
+        {
+            await item.Get('callback').call(context, properties, {callback: this.methods.callback});
+        }
+        else
+        {
+            const options = {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    id: item.Get('id'),
+                    in: properties
+                })
+            };
+
+            try 
+            {
+                const response = await fetch('/api/commands/run', options);
+                const result = await response.json();
+
+                if(result.code !== 200)
+                {
+                    throw new Error(result.message);
+                }
+
+                return this.methods.callback(result.data.data, result.data.message, result.data.code);
+            }
+            catch(error)
+            {
+                return this.methods.callback(null, error.message, 500);
+            }
+        }
+    };
+
+    this.methods.callback = (data, message = "Command '{{command}}' executed successfully.", code = 200) => 
+    {
+        if(message === null && code === 404)
+        {
+            message = 'The requested resource cannot be found.';
+        }
+
+        if(code >= 200 && code < 300 && item.Get('out'))
+        {
+            try 
+            {
+                data = divhunt.DataDefine(data, item.Get('out'));
+            }
+            catch(error)
+            {
+                throw new Error('Command OUT Error. ' + error.message);
+            }
+        }
+        else if(code < 200 || code >= 300)
+        {
+            data = {};
+        }
+
+        this.methods.resolve({data, message: message?.replace('{{command}}', item.Get('id')), code});
+    };
+
+    return new Promise((resolve, reject) => 
+    {
+        try 
+        {
+            this.methods.init(resolve, reject);    
+        }
+        catch(error)
+        {
+            this.methods.resolve({data: error.message, message: 'Internal server error.', code: 500});
+        }
+    });
+});

package/addons/core/commands/front/items/elements/table/table.css

@@ -0,0 +1,18 @@
+/* Base */
+.e-cmd-table > .holder
+{
+	display: flex;
+	flex-direction: column;
+}
+
+.e-cmd-table > .holder > .error
+{
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	padding: var(--dh-spacing-l);
+	color: var(--dh-red);
+	font-size: var(--dh-size-m);
+	background: var(--dh-red-opacity);
+	border-radius: var(--dh-radius-m);
+}