divhunt 2.0.0

package/addons/modules/shortcuts/front/functions/register.js

@@ -0,0 +1,170 @@
+import divhunt from '#divhunt';
+import shortcuts from '../addon.js';
+
+shortcuts.Fn('register', function()
+{
+    if(this.StoreGet('registered'))
+    {
+        return;
+    }
+
+    this.StoreSet('registered', true);
+    this.StoreSet('context', null);
+
+    this.vars = divhunt.AddonGet('variables');
+
+    this.methods.handler = (e) =>
+    {
+        const key = this.methods.parse(e);
+        const items = this.methods.match(key);
+
+        for(const item of items)
+        {
+            if(this.methods.check(item, e))
+            {
+                if(item.Get('prevent'))
+                {
+                    e.preventDefault();
+                }
+
+                if(item.Get('stop'))
+                {
+                    e.stopPropagation();
+                }
+
+                this.Fn('trigger', item.Get('id'));
+            }
+        }
+    };
+
+    this.methods.parse = (e) =>
+    {
+        const parts = [];
+
+        if(e.ctrlKey) parts.push('ctrl');
+        if(e.altKey) parts.push('alt');
+        if(e.shiftKey) parts.push('shift');
+        if(e.metaKey) parts.push('meta');
+
+        const name = e.key.toLowerCase();
+
+        if(!['control', 'alt', 'shift', 'meta'].includes(name))
+        {
+            parts.push(name);
+        }
+
+        return parts.join('+');
+    };
+
+    this.methods.match = (key) =>
+    {
+        const items = [];
+
+        for(const id in this.items.data)
+        {
+            const item = this.items.data[id];
+            const itemKey = item.Get('key');
+
+            if(itemKey && itemKey.toLowerCase() === key)
+            {
+                items.push(item);
+            }
+        }
+
+        items.sort((a, b) => b.Get('priority') - a.Get('priority'));
+
+        return items;
+    };
+
+    this.methods.check = (item, e) =>
+    {
+        if(!item.Get('enabled'))
+        {
+            return false;
+        }
+
+        if(!this.methods.context(item))
+        {
+            return false;
+        }
+
+        if(!this.methods.target(item))
+        {
+            return false;
+        }
+
+        if(!this.methods.condition(item, e))
+        {
+            return false;
+        }
+
+        return true;
+    };
+
+    this.methods.context = (item) =>
+    {
+        const context = item.Get('context');
+        const current = this.StoreGet('context');
+
+        if(context && context !== current)
+        {
+            return false;
+        }
+
+        return true;
+    };
+
+    this.methods.target = (item) =>
+    {
+        const target = item.Get('target');
+
+        if(!target)
+        {
+            return true;
+        }
+
+        const element = document.querySelector(target);
+
+        if(!element || !element.contains(document.activeElement))
+        {
+            return false;
+        }
+
+        return true;
+    };
+
+    this.methods.condition = (item, e) =>
+    {
+        const condition = item.Get('condition');
+
+        if(!condition)
+        {
+            return true;
+        }
+
+        if(typeof condition === 'function')
+        {
+            return condition(e);
+        }
+
+        if(typeof condition === 'string' && this.vars)
+        {
+            const processed = this.vars.Fn('process', condition);
+
+            try
+            {
+                return divhunt.Function(`return ${processed}`)();
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        return true;
+    };
+
+    document.addEventListener('keydown', this.methods.handler);
+
+    this.StoreSet('handler', this.methods.handler);
+});

package/addons/modules/shortcuts/front/functions/trigger.js

@@ -0,0 +1,140 @@
+import divhunt from '#divhunt';
+import shortcuts from '../addon.js';
+
+shortcuts.Fn('trigger', function(id, props = {})
+{
+    this.resolve = null;
+    this.item = null;
+    this.events = divhunt.AddonGet('events');
+    this.commands = divhunt.AddonGet('commands');
+    this.actions = divhunt.AddonGet('actions');
+
+    this.methods.init = async (resolve) =>
+    {
+        this.resolve = resolve;
+        this.item = this.ItemGet(id);
+
+        if(!this.item)
+        {
+            return this.methods.done(null, `Shortcut "${id}" not found.`, 404);
+        }
+
+        if(!this.item.Get('enabled'))
+        {
+            return this.methods.done(null, `Shortcut "${id}" is disabled.`, 403);
+        }
+
+        this.methods.emit();
+
+        const callback = this.item.Get('callback');
+        const command = this.item.Get('command');
+        const action = this.item.Get('action');
+
+        if(callback)
+        {
+            await this.methods.callback(callback, props);
+        }
+        else if(command)
+        {
+            await this.methods.command(command, props);
+        }
+        else if(action)
+        {
+            await this.methods.action(action, props);
+        }
+        else
+        {
+            return this.methods.done(null, `Shortcut "${id}" has no callback, command, or action.`, 400);
+        }
+    };
+
+    this.methods.emit = () =>
+    {
+        if(this.events)
+        {
+            this.events.Fn('emit', 'shortcut.triggered', {
+                id,
+                key: this.item.Get('key')
+            });
+        }
+    };
+
+    this.methods.callback = async (fn, props) =>
+    {
+        try
+        {
+            const data = await fn(props);
+            return this.methods.done(data, 'Shortcut executed.', 200);
+        }
+        catch(error)
+        {
+            return this.methods.done(null, error.message, 500);
+        }
+    };
+
+    this.methods.command = async (command, props) =>
+    {
+        if(!this.commands)
+        {
+            return this.methods.done(null, 'Commands addon not available.', 500);
+        }
+
+        const commandId = typeof command === 'string' ? command : command.id;
+        const merged = typeof command === 'object' ? { ...command, ...props, id: undefined } : props;
+
+        const item = this.commands.ItemGet(commandId);
+
+        if(!item)
+        {
+            return this.methods.done(null, `Command "${commandId}" not found.`, 404);
+        }
+
+        try
+        {
+            const result = await item.Fn('run', merged);
+            return this.methods.done(result.data, result.message, result.code);
+        }
+        catch(error)
+        {
+            return this.methods.done(null, error.message, 500);
+        }
+    };
+
+    this.methods.action = async (action, props) =>
+    {
+        if(!this.actions)
+        {
+            return this.methods.done(null, 'Actions addon not available.', 500);
+        }
+
+        const actionId = typeof action === 'string' ? action : action.id;
+        const merged = typeof action === 'object' ? { ...action, ...props, id: undefined } : props;
+
+        try
+        {
+            const result = await this.actions.Fn('run', actionId, merged);
+            return this.methods.done(result.data, result.message, result.code);
+        }
+        catch(error)
+        {
+            return this.methods.done(null, error.message, 500);
+        }
+    };
+
+    this.methods.done = (data, message, code) =>
+    {
+        this.resolve({ data, message, code });
+    };
+
+    return new Promise((resolve) =>
+    {
+        try
+        {
+            this.methods.init(resolve);
+        }
+        catch(error)
+        {
+            resolve({ data: null, message: error.message, code: 500 });
+        }
+    });
+});

package/addons/modules/shortcuts/front/functions/unregister.js

@@ -0,0 +1,19 @@
+import shortcuts from '../addon.js';
+
+shortcuts.Fn('unregister', function()
+{
+    if(!this.StoreGet('registered'))
+    {
+        return;
+    }
+
+    const handler = this.StoreGet('handler');
+
+    if(handler)
+    {
+        document.removeEventListener('keydown', handler);
+    }
+
+    this.StoreSet('registered', false);
+    this.StoreSet('handler', null);
+});

package/addons/modules/shortcuts/front/load.js

@@ -0,0 +1,12 @@
+import shortcuts from './addon.js';
+
+import './functions/register.js';
+import './functions/unregister.js';
+import './functions/trigger.js';
+import './functions/enable.js';
+import './functions/disable.js';
+import './functions/context.js';
+
+shortcuts.Fn('register');
+
+export default shortcuts;

package/addons/modules/sources/back/addon.js

@@ -0,0 +1,23 @@
+import divhunt from '#divhunt';
+
+const sources = divhunt.Addon('sources', (addon) =>
+{
+    addon.Table('sources');
+
+    addon.Field('id', ['string']);
+    addon.Field('name', ['string', null]);
+    addon.Field('group', ['string', null]);
+    addon.Field('description', ['string', null]);
+    addon.Field('command', ['string|object', null]);
+    addon.Field('endpoint', ['string', null]);
+    addon.Field('method', ['string', 'GET']);
+    addon.Field('headers', ['object', null]);
+    addon.Field('body', ['object|string', null]);
+    addon.Field('in', ['object', null]);
+    addon.Field('out', ['object', null]);
+    addon.Field('callback', ['function', null]);
+    addon.Field('created_at', ['string', null]);
+    addon.Field('updated_at', ['string', null]);
+});
+
+export default sources;

package/addons/modules/sources/back/functions/run.js

@@ -0,0 +1,252 @@
+import divhunt from '#divhunt';
+import sources from '../addon.js';
+
+sources.Fn('run', function(id, props = {})
+{
+    this.resolve = null;
+    this.item = null;
+    this.vars = divhunt.AddonGet('variables');
+    this.commands = divhunt.AddonGet('commands');
+
+    this.methods.init = async (resolve) =>
+    {
+        this.resolve = resolve;
+        this.item = this.ItemGet(id);
+
+        if(!this.item)
+        {
+            return this.methods.done(null, `Source "${id}" not found.`, 404);
+        }
+
+        props = this.methods.validate(props, 'in');
+
+        if(props === false)
+        {
+            return;
+        }
+
+        const callback = this.item.Get('callback');
+        const command = this.item.Get('command');
+
+        if(callback)
+        {
+            await this.methods.callback(callback, props);
+        }
+        else if(command)
+        {
+            await this.methods.command(command, props);
+        }
+        else
+        {
+            await this.methods.http(props);
+        }
+    };
+
+    this.methods.validate = (data, type) =>
+    {
+        const schema = this.item.Get(type);
+
+        if(!schema)
+        {
+            return data;
+        }
+
+        try
+        {
+            return divhunt.DataDefine(data, schema);
+        }
+        catch(error)
+        {
+            this.methods.done(null, error.message, type === 'in' ? 400 : 500);
+            return false;
+        }
+    };
+
+    this.methods.callback = async (fn, props) =>
+    {
+        try
+        {
+            const data = await fn(props);
+            return this.methods.done(data, 'Source executed.', 200);
+        }
+        catch(error)
+        {
+            return this.methods.done(null, error.message, 500);
+        }
+    };
+
+    this.methods.command = async (command, props) =>
+    {
+        if(!this.commands)
+        {
+            return this.methods.done(null, 'Commands addon not available.', 500);
+        }
+
+        const commandId = typeof command === 'string' ? command : command.id;
+        const merged = typeof command === 'object' ? { ...command, ...props, id: undefined } : props;
+
+        const item = this.commands.ItemGet(commandId);
+
+        if(!item)
+        {
+            return this.methods.done(null, `Command "${commandId}" not found.`, 404);
+        }
+
+        try
+        {
+            const result = await item.Fn('run', merged);
+            return this.methods.done(result.data, result.message, result.code);
+        }
+        catch(error)
+        {
+            return this.methods.done(null, error.message, 500);
+        }
+    };
+
+    this.methods.http = async (props) =>
+    {
+        const endpoint = this.item.Get('endpoint');
+
+        if(!endpoint)
+        {
+            return this.methods.done(null, `Source "${id}" has no callback, command, or endpoint.`, 400);
+        }
+
+        try
+        {
+            const url = this.methods.url(endpoint, props);
+            const opts = this.methods.options(props);
+            const res = await fetch(url, opts);
+
+            if(!res.ok)
+            {
+                return this.methods.done(null, `HTTP ${res.status}: ${res.statusText}`, res.status);
+            }
+
+            const data = await res.json();
+            return this.methods.done(data, 'Source executed.', 200);
+        }
+        catch(error)
+        {
+            return this.methods.done(null, error.message, 500);
+        }
+    };
+
+    this.methods.url = (endpoint, props) =>
+    {
+        let url = this.methods.process(endpoint);
+        const method = this.item.Get('method') || 'GET';
+
+        if(method === 'GET' && Object.keys(props).length > 0)
+        {
+            const params = new URLSearchParams();
+
+            for(const key in props)
+            {
+                if(props[key] !== null && props[key] !== undefined)
+                {
+                    params.append(key, props[key]);
+                }
+            }
+
+            url += (url.includes('?') ? '&' : '?') + params.toString();
+        }
+
+        return url;
+    };
+
+    this.methods.options = (props) =>
+    {
+        const method = this.item.Get('method') || 'GET';
+        const opts = { method };
+
+        opts.headers = this.methods.headers();
+
+        if(method !== 'GET')
+        {
+            opts.body = this.methods.body(props);
+            opts.headers['Content-Type'] = opts.headers['Content-Type'] || 'application/json';
+        }
+
+        return opts;
+    };
+
+    this.methods.headers = () =>
+    {
+        const headers = this.item.Get('headers');
+        const result = {};
+
+        if(headers)
+        {
+            for(const key in headers)
+            {
+                result[key] = this.methods.process(headers[key]);
+            }
+        }
+
+        return result;
+    };
+
+    this.methods.body = (props) =>
+    {
+        let body = this.item.Get('body') || props;
+
+        if(typeof body === 'string')
+        {
+            body = this.methods.process(body);
+        }
+        else if(typeof body === 'object')
+        {
+            body = { ...body, ...props };
+
+            for(const key in body)
+            {
+                if(typeof body[key] === 'string')
+                {
+                    body[key] = this.methods.process(body[key]);
+                }
+            }
+        }
+
+        return JSON.stringify(body);
+    };
+
+    this.methods.process = (value) =>
+    {
+        if(this.vars && typeof value === 'string')
+        {
+            return this.vars.Fn('process', value);
+        }
+
+        return value;
+    };
+
+    this.methods.done = (data, message, code) =>
+    {
+        if(code >= 200 && code < 300)
+        {
+            const validated = this.methods.validate(data, 'out');
+
+            if(validated === false)
+            {
+                return;
+            }
+
+            data = validated;
+        }
+
+        this.resolve({ data, message, code });
+    };
+
+    return new Promise((resolve) =>
+    {
+        try
+        {
+            this.methods.init(resolve);
+        }
+        catch(error)
+        {
+            resolve({ data: null, message: error.message, code: 500 });
+        }
+    });
+});

package/addons/modules/sources/back/items/create.js

@@ -0,0 +1,74 @@
+import divhunt from '#divhunt';
+import sources from '../addon.js';
+
+divhunt.AddonReady('commands', (commands) =>
+{
+    commands.Item({
+        id: 'sources:create',
+        method: 'POST',
+        endpoint: '/api/sources',
+        exposed: true,
+        description: 'Create a new source',
+        in: {
+            id: ['string', null],
+            name: ['string', null],
+            group: ['string', null],
+            description: ['string', null],
+            command: ['string|object', null],
+            endpoint: ['string', null],
+            method: ['string', 'GET'],
+            headers: ['object', null],
+            body: ['object|string', null],
+            in: ['object', null],
+            out: ['object', null]
+        },
+        out: {
+            source: ['object']
+        },
+        callback: async function(props)
+        {
+            const id = props.id || divhunt.GenerateTID();
+
+            if(sources.ItemGet(id))
+            {
+                throw new Error(`Source "${id}" already exists.`);
+            }
+
+            const item = sources.Item({
+                id,
+                name: props.name,
+                group: props.group,
+                description: props.description,
+                command: props.command,
+                endpoint: props.endpoint,
+                method: props.method,
+                headers: props.headers,
+                body: props.body,
+                in: props.in,
+                out: props.out,
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString()
+            });
+
+            await item.Create();
+
+            return {
+                source: {
+                    id: item.Get('id'),
+                    name: item.Get('name'),
+                    group: item.Get('group'),
+                    description: item.Get('description'),
+                    command: item.Get('command'),
+                    endpoint: item.Get('endpoint'),
+                    method: item.Get('method'),
+                    headers: item.Get('headers'),
+                    body: item.Get('body'),
+                    in: item.Get('in'),
+                    out: item.Get('out'),
+                    created_at: item.Get('created_at'),
+                    updated_at: item.Get('updated_at')
+                }
+            };
+        }
+    });
+});