divhunt 2.0.0

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

@@ -0,0 +1,36 @@
+import divhunt from '#divhunt';
+import sources from '../addon.js';
+
+divhunt.AddonReady('commands', (commands) =>
+{
+    commands.Item({
+        id: 'sources:delete',
+        method: 'DELETE',
+        endpoint: '/api/sources/:id',
+        exposed: true,
+        description: 'Delete a source',
+        in: {
+            id: ['string', null, true]
+        },
+        out: {
+            deleted: ['boolean']
+        },
+        callback: async function(props)
+        {
+            const item = sources.ItemGet(props.id);
+
+            if(!item)
+            {
+                throw new Error(`Source "${props.id}" not found.`);
+            }
+
+            await item.Delete();
+
+            sources.ItemRemove(props.id);
+
+            return {
+                deleted: true
+            };
+        }
+    });
+});

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

@@ -0,0 +1,80 @@
+import divhunt from '#divhunt';
+import sources from '../addon.js';
+
+divhunt.AddonReady('commands', (commands) =>
+{
+    commands.Item({
+        id: 'sources:many',
+        method: 'GET',
+        endpoint: '/api/sources',
+        exposed: true,
+        description: 'Get all sources',
+        in: {
+            page: ['number', 1],
+            limit: ['number', 50],
+            group: ['string', null]
+        },
+        out: {
+            sources: {
+                type: 'array',
+                each: {
+                    type: 'object',
+                    config: {
+                        id: ['string'],
+                        name: ['string'],
+                        group: ['string'],
+                        description: ['string'],
+                        command: ['string|object'],
+                        endpoint: ['string'],
+                        method: ['string'],
+                        headers: ['object'],
+                        body: ['object|string'],
+                        in: ['object'],
+                        out: ['object'],
+                        created_at: ['string'],
+                        updated_at: ['string']
+                    }
+                }
+            },
+            total: ['number']
+        },
+        callback: async function(props)
+        {
+            const result = [];
+
+            for(const id in sources.items.data)
+            {
+                const item = sources.items.data[id];
+
+                if(props.group && item.Get('group') !== props.group)
+                {
+                    continue;
+                }
+
+                result.push({
+                    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')
+                });
+            }
+
+            const start = (props.page - 1) * props.limit;
+            const end = start + props.limit;
+
+            return {
+                sources: result.slice(start, end),
+                total: result.length
+            };
+        }
+    });
+});

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

@@ -0,0 +1,46 @@
+import divhunt from '#divhunt';
+import sources from '../addon.js';
+
+divhunt.AddonReady('commands', (commands) =>
+{
+    commands.Item({
+        id: 'sources:one',
+        method: 'GET',
+        endpoint: '/api/sources/:id',
+        exposed: true,
+        description: 'Get a single source by ID',
+        in: {
+            id: ['string', null, true]
+        },
+        out: {
+            source: ['object']
+        },
+        callback: async function(props)
+        {
+            const item = sources.ItemGet(props.id);
+
+            if(!item)
+            {
+                throw new Error(`Source "${props.id}" not found.`);
+            }
+
+            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')
+                }
+            };
+        }
+    });
+});

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

@@ -0,0 +1,28 @@
+import divhunt from '#divhunt';
+import sources from '../addon.js';
+
+divhunt.AddonReady('commands', (commands) =>
+{
+    commands.Item({
+        id: 'sources:run',
+        method: 'POST',
+        endpoint: '/api/sources/run',
+        exposed: true,
+        description: 'Run a source by ID',
+        in: {
+            id: ['string', null, true],
+            props: ['object', {}]
+        },
+        out: {
+            data: ['any'],
+            message: ['string'],
+            code: ['number']
+        },
+        callback: async function(props)
+        {
+            const result = await sources.Fn('run', props.id, props.props || {});
+
+            return result;
+        }
+    });
+});

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

@@ -0,0 +1,110 @@
+import divhunt from '#divhunt';
+import sources from '../addon.js';
+
+divhunt.AddonReady('commands', (commands) =>
+{
+    commands.Item({
+        id: 'sources:update',
+        method: 'PUT',
+        endpoint: '/api/sources/:id',
+        exposed: true,
+        description: 'Update a source',
+        in: {
+            id: ['string', null, true],
+            name: ['string', null],
+            group: ['string', null],
+            description: ['string', null],
+            command: ['string|object', null],
+            endpoint: ['string', null],
+            method: ['string', null],
+            headers: ['object', null],
+            body: ['object|string', null],
+            in: ['object', null],
+            out: ['object', null]
+        },
+        out: {
+            source: ['object']
+        },
+        callback: async function(props)
+        {
+            const item = sources.ItemGet(props.id);
+
+            if(!item)
+            {
+                throw new Error(`Source "${props.id}" not found.`);
+            }
+
+            if(props.name !== null && props.name !== undefined)
+            {
+                item.Set('name', props.name);
+            }
+
+            if(props.group !== null && props.group !== undefined)
+            {
+                item.Set('group', props.group);
+            }
+
+            if(props.description !== null && props.description !== undefined)
+            {
+                item.Set('description', props.description);
+            }
+
+            if(props.command !== null && props.command !== undefined)
+            {
+                item.Set('command', props.command);
+            }
+
+            if(props.endpoint !== null && props.endpoint !== undefined)
+            {
+                item.Set('endpoint', props.endpoint);
+            }
+
+            if(props.method !== null && props.method !== undefined)
+            {
+                item.Set('method', props.method);
+            }
+
+            if(props.headers !== null && props.headers !== undefined)
+            {
+                item.Set('headers', props.headers);
+            }
+
+            if(props.body !== null && props.body !== undefined)
+            {
+                item.Set('body', props.body);
+            }
+
+            if(props.in !== null && props.in !== undefined)
+            {
+                item.Set('in', props.in);
+            }
+
+            if(props.out !== null && props.out !== undefined)
+            {
+                item.Set('out', props.out);
+            }
+
+            item.Set('updated_at', new Date().toISOString());
+
+            await item.Update();
+
+            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')
+                }
+            };
+        }
+    });
+});

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

@@ -0,0 +1,12 @@
+import sources from './addon.js';
+
+import './functions/run.js';
+
+import './items/one.js';
+import './items/many.js';
+import './items/create.js';
+import './items/update.js';
+import './items/delete.js';
+import './items/run.js';
+
+export default sources;

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

@@ -0,0 +1,20 @@
+import divhunt from '#divhunt';
+
+const sources = divhunt.Addon('sources', (addon) =>
+{
+    addon.Field('id', ['string']);
+    addon.Field('name', ['string', null]);
+    addon.Field('group', ['string', null]);
+    addon.Field('description', ['string', null]);
+    addon.Field('action', ['string|object', 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]);
+});
+
+export default sources;

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

@@ -0,0 +1,279 @@
+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.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, `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');
+        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
+        {
+            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.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.http = async (props) =>
+    {
+        const endpoint = this.item.Get('endpoint');
+
+        if(!endpoint)
+        {
+            return this.methods.done(null, `Source "${id}" has no callback, command, action, 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/front/load.js

@@ -0,0 +1,5 @@
+import sources from './addon.js';
+
+import './functions/run.js';
+
+export default sources;

package/addons/modules/variables/addon.js

@@ -0,0 +1,12 @@
+import divhunt from '#divhunt';
+
+const variables = divhunt.Addon('variables', (addon) =>
+{
+    addon.Field('id', ['string']);
+    addon.Field('value', ['any']);
+    addon.Field('type', ['string']);
+    addon.Field('key', ['string', null]);
+    addon.Field('group', ['string', null]);
+});
+
+export default variables;

package/addons/modules/variables/functions/filter.js

@@ -0,0 +1,24 @@
+import variables from '../addon.js';
+
+variables.Fn('filter', function(group = null)
+{
+    const result = [];
+
+    for(const id in this.items.data)
+    {
+        const item = this.items.data[id];
+
+        if(group === null || item.Get('group') === group)
+        {
+            result.push({
+                id: item.Get('id'),
+                value: item.Get('value'),
+                type: item.Get('type'),
+                key: item.Get('key'),
+                group: item.Get('group')
+            });
+        }
+    }
+
+    return result;
+});