@onetype/framework 2.0.20

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

@@ -0,0 +1,140 @@
+import onetype from '#onetype';
+import shortcuts from '../addon.js';
+
+shortcuts.Fn('trigger', function(id, props = {})
+{
+    this.resolve = null;
+    this.item = null;
+    this.events = onetype.AddonGet('events');
+    this.commands = onetype.AddonGet('commands');
+    this.actions = onetype.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 onetype from '#onetype';
+
+const sources = onetype.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 onetype from '#onetype';
+import sources from '../addon.js';
+
+sources.Fn('run', function(id, props = {})
+{
+    this.resolve = null;
+    this.item = null;
+    this.vars = onetype.AddonGet('variables');
+    this.commands = onetype.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 onetype.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 onetype from '#onetype';
+import sources from '../addon.js';
+
+onetype.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 || onetype.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')
+                }
+            };
+        }
+    });
+});

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

@@ -0,0 +1,36 @@
+import onetype from '#onetype';
+import sources from '../addon.js';
+
+onetype.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 onetype from '#onetype';
+import sources from '../addon.js';
+
+onetype.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 onetype from '#onetype';
+import sources from '../addon.js';
+
+onetype.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')
+                }
+            };
+        }
+    });
+});