@onetype/framework 2.0.20

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

@@ -0,0 +1,28 @@
+import onetype from '#onetype';
+import sources from '../addon.js';
+
+onetype.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 onetype from '#onetype';
+import sources from '../addon.js';
+
+onetype.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 onetype from '#onetype';
+
+const sources = onetype.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 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.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, `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 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.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/core/addon.js

@@ -0,0 +1,11 @@
+import onetype from '#framework/load.js';
+
+const variables = onetype.Addon('variables', (addon) =>
+{
+    addon.Field('id', ['string']);
+    addon.Field('value', ['any']);
+    addon.Field('type', ['string']);
+    addon.Field('group', ['string', null]);
+});
+
+export default variables;

package/addons/modules/variables/core/functions/process.js

@@ -0,0 +1,46 @@
+import onetype from '#framework/load.js';
+import variables from '#variables/core/addon.js';
+
+variables.Fn('process', function(string)
+{
+    if(typeof string !== 'string')
+    {
+        return string;
+    }
+
+    const safe = onetype.environment === 'back';
+    const data = {};
+
+    for(const id in this.items.data)
+    {
+        data[id] = this.items.data[id].Get('value');
+    }
+
+    if(!string.includes('${'))
+    {
+        const result = onetype.Function(string, data, safe);
+
+        return result !== undefined ? result : string;
+    }
+
+    const single = string.match(/^\$\{([^}]+)\}$/);
+
+    if(single)
+    {
+        const result = onetype.Function(single[1], data, safe);
+
+        return result !== undefined ? result : string;
+    }
+
+    return string.replace(/\$\{([^}]+)\}/g, (match, expression) =>
+    {
+        const result = onetype.Function(expression, data, safe);
+
+        if(result === undefined || (typeof result === 'object' && result !== null))
+        {
+            return match;
+        }
+
+        return result;
+    });
+});

package/addons/modules/variables/core/item/catch/add.js

@@ -0,0 +1,6 @@
+import variables from '#variables/core/addon.js';
+
+variables.ItemOn('add', function(item)
+{
+    item.Set('type', typeof item.Get('value'));
+});

package/addons/modules/variables/core/load.js

@@ -0,0 +1,13 @@
+import onetype from '#framework/load.js';
+import variables from '#variables/core/addon.js';
+
+import '#variables/core/item/catch/add.js';
+
+import '#variables/core/functions/process.js';
+
+onetype.$ot.var = function(string)
+{
+    return variables.Fn('process', string);
+};
+
+export default variables;

package/addons/render/assets/back/README.md

@@ -0,0 +1 @@
+# assets

package/addons/render/assets/back/addon.js

@@ -0,0 +1,13 @@
+import onetype from '#framework/load.js';
+
+const assets = onetype.Addon('assets', (addon) =>
+{
+    addon.Field('id', ['number']);
+    addon.Field('order', ['number']);
+    addon.Field('path', ['string']);
+    addon.Field('content', ['string|function']);
+    addon.Field('type', ['string']);
+    addon.Field('ignore', ['array', []]);
+});
+
+export default assets;

package/addons/render/assets/back/functions/css.js

@@ -0,0 +1,30 @@
+import assets from '../addon.js';
+
+assets.Fn('css', function()
+{
+    const css = [];
+    const items = Object.values(this.Items()).filter(item => item.Get('type') === 'css').sort((a, b) => a.Get('order') - b.Get('order'));
+    
+    items.forEach((item) => 
+    {
+        if(item.Get('content'))
+        {
+            if(typeof item.Get('content') === 'function')
+            {
+                css.push(item.Get('content')());
+            }
+            else 
+            {
+                css.push(item.Get('content'));
+            }
+        }
+        else if(item.Get('path'))
+        {
+            const files = assets.Fn('scan.files', item.Get('path'), 'css', item.Get('ignore'));
+
+            css.push(...assets.Fn('utils.read', files));
+        }
+    })
+
+    return assets.Fn('utils.transform', css, 'css');
+});

package/addons/render/assets/back/functions/import.js

@@ -0,0 +1,45 @@
+import assets from '../addon.js';
+
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..', '..', '..', '..');
+
+const map =
+{
+    framework:  { js: 'lib', ignore: ['lib/load.js'] },
+    commands:   { js: 'addons/core/commands', ignore: ['addons/core/commands/back'] },
+    database:   { js: 'addons/core/database/front' },
+    actions:    { js: 'addons/modules/actions/front' },
+    variables:  { js: 'addons/modules/variables' },
+    bugs:       { js: 'addons/modules/bugs/front' },
+    events:     { js: 'addons/modules/events/front' },
+    schedules:  { js: 'addons/modules/schedules/front' },
+    shortcuts:  { js: 'addons/modules/shortcuts/front' },
+    sources:    { js: 'addons/modules/sources/front' },
+    directives: { js: 'addons/render/directives/front' },
+    transforms: { js: 'addons/render/transforms/front' },
+    pages:      { js: 'addons/render/pages', css: 'addons/render/pages/front' },
+    elements:   { js: 'addons/render/elements/front', css: 'addons/render/elements/front' },
+    float:      { js: 'addons/float', css: 'addons/float' }
+};
+
+assets.Fn('import', function(modules)
+{
+    for (let i = 0; i < modules.length; i++)
+    {
+        const config = map[modules[i]];
+
+        if (!config) continue;
+
+        if (config.js)
+        {
+            assets.Item({ type: 'js', order: i, path: resolve(root, config.js), ignore: config.ignore || [] });
+        }
+
+        if (config.css)
+        {
+            assets.Item({ type: 'css', order: i, path: resolve(root, config.css) });
+        }
+    }
+});

package/addons/render/assets/back/functions/js.js

@@ -0,0 +1,30 @@
+import assets from '../addon.js';
+
+assets.Fn('js', function(context = {})
+{
+    const js = [];
+    const items = Object.values(this.Items()).filter(item => item.Get('type') === 'js').sort((a, b) => a.Get('order') - b.Get('order'));
+
+    items.forEach((item) =>
+    {
+        if(item.Get('content'))
+        {
+            if(typeof item.Get('content') === 'function')
+            {
+                js.push(item.Get('content').call(context));
+            }
+            else
+            {
+                js.push(item.Get('content'));
+            }
+        }
+        else if(item.Get('path'))
+        {
+            const files = assets.Fn('scan.files', item.Get('path'), 'js', item.Get('ignore'));
+
+            js.push(...assets.Fn('utils.read', files));
+        }
+    })
+
+    return assets.Fn('utils.transform', js, 'js');
+});