nesoi 3.0.0

package/lib/engine/apps/monolyth/monolyth.cli.js

@@ -0,0 +1,362 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Color = exports.MonolythCLI = void 0;
+const package_json_1 = __importDefault(require("../../../../package.json"));
+const readline = __importStar(require("readline"));
+const path = __importStar(require("path"));
+const stream_1 = require("stream");
+const fs = __importStar(require("fs"));
+const cli_controller_adapter_1 = require("../../../elements/edge/controller/adapters/cli.controller_adapter");
+const typescript_compiler_1 = require("../../../compiler/typescript/typescript_compiler");
+const shell_1 = __importDefault(require("../../util/shell"));
+class MonolythCLI {
+    constructor(
+    // private space: Space<any>,
+    trxEngines) {
+        this.trxEngines = trxEngines;
+    }
+    async run() {
+        Console.header('CLI');
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const context = this.module ? `${this.module}>` : '>';
+            const cmd = await Console.question(context);
+            if (await this.runCmd(cmd)) {
+                break;
+            }
+        }
+    }
+    async runCmd(cmd) {
+        // > help
+        // Exit the CLI
+        if (cmd === 'help') {
+            this.cmdHelp();
+            return false;
+        }
+        // > exit
+        if (cmd === 'exit') {
+            return true;
+        }
+        // > clear
+        if (cmd === 'clear') {
+            this.cmdClear();
+            return false;
+        }
+        // > @
+        if (cmd === '@') {
+            await this.cmdListModules();
+            return false;
+        }
+        // > invoke
+        if (cmd === 'invoke') {
+            await this.cmdInvokeInteractive();
+            return false;
+        }
+        // > @[MODULE_NAME]
+        if (this.cmdPickModule(cmd)) {
+            return false;
+        }
+        // > invoke [ENDPOINT_PATH] [DATA_JSON]
+        if (await this.cmdInvoke(cmd)) {
+            return false;
+        }
+        Console.error('Invalid command');
+        return false;
+    }
+    cmdHelp() {
+        Console.step('Welcome to the Nesoi Monolyth CLI.');
+        console.log('' +
+            `\t${Console.colored('help', 'lightcyan')}\t\tShow this info\n` +
+            `\t${Console.colored('exit', 'lightcyan')}\t\tClose the CLI\n` +
+            `\t${Console.colored('@', 'lightcyan')}\t\tInteractively switch to a module\n` +
+            `\t${Console.colored('@[MODULE_NAME]', 'lightcyan')}\tSwitch to a module by name\n` +
+            `\t${Console.colored('invoke', 'lightcyan')}\t\tInteractively invoke a message to a controller\n`);
+    }
+    async cmdClear() {
+        console.clear();
+    }
+    async cmdListModules() {
+        const module = await Console.select('Pick a module from the list below:', Object.keys(this.trxEngines));
+        this.cmdPickModule(`@${module}`);
+    }
+    async cmdInvokeInteractive() {
+        if (!this.module) {
+            Console.error('No module selected. Use "@" to switch to the desired module first.');
+            return;
+        }
+        const module = this.trxEngines[this.module].getModule();
+        const adapters = Object.entries(module.controllers)
+            .reduce((a, [name, controller]) => {
+            if (controller.adapter instanceof cli_controller_adapter_1.CLIControllerAdapter) {
+                a[name] = controller.adapter;
+            }
+            return a;
+        }, {});
+        const controllerName = await Console.select('Pick a controller from the list below:', Object.keys(adapters));
+        const adapter = adapters[controllerName];
+        const endpointName = await Console.select('Pick an endpoint from the list below:', Object.keys(adapter.endpoints));
+        const endpoint = adapter.endpoints[endpointName];
+        const tmpInputFile = (Math.random() + 1).toString(36).substring(7) + '.cli.tmp.ts';
+        const tmpInputFilePath = path.join(process.cwd(), tmpInputFile);
+        const tmpInput = ''
+            + 'import { CLIData as _ } from \'nesoi/lib/engine/apps/monolyth.cli\';\n'
+            + `import $ from '${path.join(process.cwd(), 'types', module.name + '.module')}';\n`
+            + '\n'
+            + `export const data: _<$, '${endpoint.schema.msg.refName}'> = {\n\t\n};`;
+        fs.writeFileSync(tmpInputFilePath, tmpInput);
+        shell_1.default.cmd('', `code ${tmpInputFilePath}`);
+        await Console.waitForAnyKey();
+        const compiled = typescript_compiler_1.TypeScriptCompiler.compileFile(tmpInputFilePath);
+        fs.writeFileSync(tmpInputFilePath, compiled);
+        const data = (await Promise.resolve(`${tmpInputFilePath}`).then(s => __importStar(require(s)))).data;
+        Console.cmd(`invoke ${endpoint.path} ${JSON.stringify(data)}`);
+        Console.info(`Invoking endpoint ${endpoint.path}`);
+        const response = await endpoint.invoke(data);
+        console.log({ output: response.output });
+        console.log(response.summary());
+        fs.rmSync(tmpInputFile);
+    }
+    cmdPickModule(cmd) {
+        const module = /@(\w*)/.exec(cmd)?.[1];
+        if (!module) {
+            return false;
+        }
+        Console.info(`Switching to module '${module}'`);
+        if (!(module in this.trxEngines)) {
+            Console.error(`Module '${module}' not found on app`);
+            return true;
+        }
+        this.module = module;
+        return true;
+    }
+    async cmdInvoke(cmd) {
+        if (!this.module) {
+            Console.error('No module selected. Use "@" to switch to the desired module first.');
+            return true;
+        }
+        const parsed = /invoke (.*?) (.*)/.exec(cmd);
+        if (!parsed) {
+            return false;
+        }
+        const [_, endpointName, json] = parsed;
+        const controllerName = /\/(.*?)\//.exec(endpointName)?.[1];
+        if (!controllerName) {
+            Console.error('Invalid endpoint format');
+            return false;
+        }
+        const module = this.trxEngines[this.module].getModule();
+        const adapters = Object.entries(module.controllers)
+            .reduce((a, [name, controller]) => {
+            if (controller.adapter instanceof cli_controller_adapter_1.CLIControllerAdapter) {
+                a[name] = controller.adapter;
+            }
+            return a;
+        }, {});
+        const adapter = adapters[controllerName];
+        const endpoint = adapter.endpoints[endpointName];
+        if (!endpoint) {
+            Console.error('Endpoint not found');
+            return false;
+        }
+        let data;
+        try {
+            data = JSON.parse(json);
+        }
+        catch {
+            Console.error('Invalid json');
+            return false;
+        }
+        Console.info(`Invoking endpoint ${endpoint.path}`);
+        const response = await endpoint.invoke(data);
+        console.log(response.summary());
+        return true;
+    }
+}
+exports.MonolythCLI = MonolythCLI;
+// Console helpers (this should be moved somewhere when the CLI matures)
+var Color;
+(function (Color) {
+    Color["black"] = "0;30";
+    Color["red"] = "0;31";
+    Color["green"] = "0;32";
+    Color["brown"] = "0;33";
+    Color["blue"] = "0;34";
+    Color["purple"] = "0;35";
+    Color["cyan"] = "0;36";
+    Color["lightgray"] = "0;37";
+    Color["darkgray"] = "1;30";
+    Color["lightred"] = "1;31";
+    Color["lightgreen"] = "1;32";
+    Color["yellow"] = "1;33";
+    Color["lightblue"] = "1;34";
+    Color["lightpurple"] = "1;35";
+    Color["lightcyan"] = "1;36";
+})(Color || (exports.Color = Color = {}));
+class Console {
+    // Returns colored message
+    static colored(msg, color) {
+        return '\x1b[' + Color[color] + 'm' + msg + '\x1b[0m';
+    }
+    // Show a list of options and let the user pick with up/down + enter
+    static async select(title, options, defaul = 0) {
+        return new Promise(resolve => {
+            Console.step(title);
+            let mute = true;
+            const mutableStdout = new stream_1.Writable({
+                write: function (chunk, encoding, callback) {
+                    if (!mute) {
+                        process.stdout.write(chunk, encoding);
+                    }
+                    callback();
+                }
+            });
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: mutableStdout,
+                terminal: true
+            });
+            let selected = defaul;
+            const print = () => {
+                mute = false;
+                for (let i = 0; i < options.length; i++) {
+                    rl.write(this.colored(`${i === selected ? '» ' : '  '}` + options[i] + '\n', i === selected ? 'lightgreen' : 'lightgray'));
+                }
+                mute = true;
+            };
+            const clear = () => {
+                process.stdout.moveCursor(0, -options.length);
+            };
+            const onKeypress = function (ch, key) {
+                if (!key) {
+                    return;
+                }
+                if (key.name === 'up') {
+                    if (selected > 0) {
+                        selected -= 1;
+                    }
+                }
+                else if (key.name === 'down') {
+                    if (selected < options.length - 1) {
+                        selected += 1;
+                    }
+                }
+                else if (key.name === 'return') {
+                    rl.close();
+                    process.stdin.off('keypress', onKeypress);
+                    resolve(options[selected]);
+                }
+                clear();
+                print();
+            };
+            process.stdin.on('keypress', onKeypress);
+            print();
+        });
+    }
+    // Ask a question and wait for the answer
+    static async question(text, defaul = '', prefix = '') {
+        return new Promise(resolve => {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout
+            });
+            rl.question(this.colored(text + ' ', 'cyan') + prefix, val => {
+                rl.close();
+                resolve(val);
+            });
+            rl.write(defaul);
+        });
+    }
+    static waitForAnyKey(title = 'Press any key to continue...') {
+        return new Promise(resolve => {
+            Console.step(title);
+            const mutableStdout = new stream_1.Writable({
+                write: function (chunk, encoding, callback) {
+                }
+            });
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: mutableStdout,
+                terminal: true
+            });
+            const onKeypress = function (ch, key) {
+                rl.close();
+                process.stdin.off('keypress', onKeypress);
+                resolve();
+            };
+            process.stdin.on('keypress', onKeypress);
+        });
+    }
+    // Ask a yes or no question and wait for the answer
+    static async yesOrNo(text, defaul = 'n') {
+        let answer = await this.question(text + ' [y|n]', defaul);
+        answer = answer.toLowerCase();
+        if (answer === 'y' || answer === 'yes')
+            return true;
+        return false;
+    }
+    // Prints a step message to the terminal
+    static step(msg) {
+        console.log(this.colored('- ' + msg, 'green'));
+    }
+    // Prints a info message to the terminal
+    static info(msg) {
+        console.log(this.colored(msg, 'lightblue'));
+    }
+    // Prints a info message to the terminal
+    static cmd(msg) {
+        console.log(this.colored('\n\t> ' + msg + '\n', 'darkgray'));
+    }
+    // Prints a error message to the terminal
+    static error(msg) {
+        console.log(this.colored('! ' + msg, 'red'));
+    }
+    // Prints the header
+    static header(module) {
+        console.log(this.colored('                              __', 'lightblue'));
+        console.log(this.colored('  ___      __    ____    ___ /\\_\\', 'lightblue'));
+        console.log(this.colored(' /\'_ `\\  /\'__`\\ /\',__\\  / __`\\/\\ \\', 'lightblue'));
+        console.log(this.colored('/\\ \\/\\ \\/\\  __//\\__, `\\/\\ \\L\\ \\ \\ \\', 'lightblue'));
+        console.log(this.colored('\\ \\_\\ \\_\\ \\____\\/\\____/\\ \\____/\\ \\_\\', 'lightblue'));
+        console.log(this.colored(' \\/_/\\/_/\\/____/\\/___/  \\/___/  \\/_/', 'lightblue'));
+        console.log(this.colored('                          ' + package_json_1.default.version, 'cyan'));
+        console.log('[ ' + module + ' ]');
+        console.log();
+    }
+}
+exports.default = Console;

package/lib/engine/auth/authn.d.ts

@@ -0,0 +1,18 @@
+import { NesoiObjId } from '../data/obj';
+export type User = {
+    id: NesoiObjId;
+    [x: string]: any;
+};
+export type AuthnToken = string;
+export type AuthnRequest<P extends keyof any> = {
+    [K in P]?: AuthnToken;
+};
+export declare abstract class AuthnProvider<U extends User> {
+    abstract authenticate(token: AuthnToken): Promise<U>;
+}
+export type AnyAuthnProviders = {
+    [K: string]: AuthnProvider<any>;
+};
+export type AnyUsers = {
+    [K: string]: User;
+};

package/lib/engine/auth/authn.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthnProvider = void 0;
+/*
+    Provider
+*/
+class AuthnProvider {
+}
+exports.AuthnProvider = AuthnProvider;

package/lib/engine/auth/zero.authn_provider.d.ts

@@ -0,0 +1,13 @@
+import { NesoiObjId } from '../data/obj';
+import { AuthnProvider, AuthnToken } from './authn';
+type ZeroUser = {
+    id: NesoiObjId;
+    name: string;
+};
+export declare class ZeroAuthnProvider extends AuthnProvider<ZeroUser> {
+    authenticate(_token: AuthnToken): Promise<{
+        id: number;
+        name: string;
+    }>;
+}
+export {};

package/lib/engine/auth/zero.authn_provider.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZeroAuthnProvider = void 0;
+const authn_1 = require("./authn");
+class ZeroAuthnProvider extends authn_1.AuthnProvider {
+    async authenticate(_token) {
+        return Promise.resolve({
+            id: 0,
+            name: 'User Zero'
+        });
+    }
+}
+exports.ZeroAuthnProvider = ZeroAuthnProvider;

package/lib/engine/cli/cli.d.ts

@@ -0,0 +1,19 @@
+import { AnyDaemon } from '../daemon';
+import { CLIAdapter } from './cli_adapter';
+export type CLIConfig<Providers> = {
+    adapters?: {
+        [x: string]: (providers: Providers) => CLIAdapter;
+    };
+};
+export declare class CLI {
+    private daemon;
+    config?: CLIConfig<any> | undefined;
+    private app;
+    private ctx;
+    private adapters;
+    constructor(daemon: AnyDaemon, config?: CLIConfig<any> | undefined);
+    run(): Promise<void>;
+    private runCmd;
+    private cmdHelp;
+    private cmdClear;
+}

package/lib/engine/cli/cli.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLI = void 0;
+const string_1 = require("../util/string");
+const ui_1 = __importDefault(require("./ui"));
+const console_1 = __importDefault(require("../util/console"));
+const daemon_1 = require("../daemon");
+const log_1 = require("../util/log");
+class CLI {
+    constructor(daemon, config) {
+        this.daemon = daemon;
+        this.config = config;
+        this.ctx = '';
+        this.adapters = {};
+        this.app = daemon_1.Daemon.get(daemon, 'name') || 'app';
+        // Build adapters
+        this.adapters = {};
+        Object.entries(config?.adapters || {}).forEach(([key, val]) => {
+            this.adapters[key] = val(daemon_1.Daemon.get(daemon, 'providers'));
+            this.adapters[key].name = key;
+        });
+    }
+    async run() {
+        console_1.default.header('CLI');
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const ctx = `${(0, string_1.colored)(this.app, 'darkgray')}:${(0, string_1.colored)(this.ctx, 'lightcyan')}${(0, string_1.colored)('$', 'brown')}`;
+            const cmd = await ui_1.default.question(ctx);
+            try {
+                if (await this.runCmd(cmd)) {
+                    break;
+                }
+            }
+            catch (e) {
+                console.error(e);
+                log_1.Log.error('cli', daemon_1.Daemon.get(this.daemon, 'name'), `Failed to run command: ${cmd}`);
+            }
+        }
+    }
+    async runCmd(payload) {
+        payload = payload.trim();
+        // > help
+        // Exit the CLI
+        if (payload === 'help') {
+            this.cmdHelp();
+            return false;
+        }
+        // > exit
+        if (payload === 'exit') {
+            return true;
+        }
+        // > clear
+        if (payload === 'clear') {
+            this.cmdClear();
+            return false;
+        }
+        for (const name in this.adapters) {
+            if (!payload.startsWith(name))
+                continue;
+            payload = payload.replace(name, '').trim();
+            const adapter = this.adapters[name];
+            if (await adapter.runCmd(this.daemon, payload)) {
+                return false;
+            }
+        }
+        ui_1.default.error('Invalid command');
+        return false;
+    }
+    cmdHelp() {
+        ui_1.default.step('\nWelcome to the Nesoi CLI!\n');
+        let str = '' +
+            `${(0, string_1.colored)('general', 'brown')}\n` +
+            `\t${(0, string_1.colored)('help', 'lightcyan')}\n\t\tShow this info\n` +
+            `\t${(0, string_1.colored)('exit', 'lightcyan')}\n\t\tClose the CLI\n` +
+            `\t${(0, string_1.colored)('clear', 'lightcyan')}\n\t\tClear the sceen\n`;
+        Object.values(this.adapters).forEach(adapter => {
+            str += adapter.help();
+        });
+        console.log(str);
+    }
+    async cmdClear() {
+        console.clear();
+    }
+}
+exports.CLI = CLI;

package/lib/engine/cli/cli_adapter.d.ts

@@ -0,0 +1,18 @@
+import { AnyDaemon } from '../daemon';
+export declare abstract class CLICommand<T extends Record<string, any> = Record<string, any>> {
+    name: string;
+    syntax: string;
+    description: string;
+    regex?: RegExp | undefined;
+    groups?: string[] | undefined;
+    constructor(name: string, syntax: string, description: string, regex?: RegExp | undefined, groups?: string[] | undefined);
+    input(payload: string): Record<string, any>;
+    abstract run(daemon: AnyDaemon, input: T): Promise<void>;
+}
+export declare abstract class CLIAdapter {
+    name?: string;
+    commands: Record<string, CLICommand>;
+    constructor();
+    runCmd(daemon: AnyDaemon, payload: string): Promise<boolean>;
+    help(): string;
+}

package/lib/engine/cli/cli_adapter.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIAdapter = exports.CLICommand = void 0;
+const string_1 = require("../util/string");
+class CLICommand {
+    constructor(name, syntax, description, regex, groups) {
+        this.name = name;
+        this.syntax = syntax;
+        this.description = description;
+        this.regex = regex;
+        this.groups = groups;
+    }
+    input(payload) {
+        if (!this.regex) {
+            return {};
+        }
+        const match = payload.match(this.regex);
+        if (!match) {
+            throw new Error(`Invalid input for command ${this.name}`);
+        }
+        const data = {};
+        if (this.groups) {
+            for (let i = 0; i < this.groups.length; i++) {
+                const key = this.groups[i];
+                data[key] = match[i + 1];
+            }
+        }
+        return data;
+    }
+}
+exports.CLICommand = CLICommand;
+class CLIAdapter {
+    constructor() {
+        this.commands = {};
+    }
+    async runCmd(daemon, payload) {
+        payload = payload.trim();
+        let cmd;
+        for (const name in this.commands) {
+            if (!payload.startsWith(name))
+                continue;
+            payload = payload.replace(name, '').trim();
+            cmd = this.commands[name];
+        }
+        if (!cmd) {
+            return false;
+        }
+        const input = cmd.input(payload);
+        await cmd.run(daemon, input);
+        return true;
+    }
+    help() {
+        const name = this.name || '?';
+        let str = `${(0, string_1.colored)(name, 'brown')}\n`;
+        Object.values(this.commands).forEach(cmd => {
+            str += `\t${(0, string_1.colored)(name + ' ' + cmd.syntax, 'lightcyan')}\n\t\t${cmd.description}\n`;
+        });
+        return str;
+    }
+}
+exports.CLIAdapter = CLIAdapter;

package/lib/engine/cli/ui.d.ts

@@ -0,0 +1,36 @@
+export default class UI {
+    /**
+     * Show a list of options and let the user pick with up/down + enter
+     */
+    static select(title: string, options: string[], defaul?: number): Promise<string>;
+    /**
+     * Ask a question and wait for the answer
+     */
+    static question(text: string, defaul?: string, prefix?: string): Promise<string>;
+    /**
+     * Show a message and wait for the user to press any key
+     */
+    static waitForAnyKey(title?: string): Promise<void>;
+    /**
+     * Ask a yes or no question and wait for the answer
+     */
+    static yesOrNo(text: string, defaul?: 'y' | 'n'): Promise<boolean>;
+    static list(items: string[]): void;
+    static result(outcome: 'ok' | 'error', message: string, details?: any): void;
+    /**
+     * Print a step message to the terminal
+     */
+    static step(msg: string): void;
+    /**
+     * Print a info message to the terminal
+     */
+    static info(msg: string): void;
+    /**
+     * Print a command to the terminal
+     */
+    static cmd(msg: string): void;
+    /**
+     * Print a error message to the terminal
+     */
+    static error(msg: string): void;
+}