nesoi 3.0.0

package/lib/engine/apps/app.d.ts

@@ -0,0 +1,70 @@
+import { $Space, ModuleName } from "../../schema";
+import { AnyBuilder, AnyModule } from '../module';
+import { Space } from '../space';
+import { Daemon } from '../daemon';
+import { AnyAppConfig, AppConfigFactory } from './app.config';
+/**
+ * Provider
+ */
+export type AppProvider<out Name, T> = {
+    name: Name;
+    up: ($: {
+        modules: Record<string, AnyModule>;
+    }) => T;
+    down: (provider: NoInfer<T>) => any;
+};
+export type AnyAppProvider = AppProvider<any, any>;
+export declare abstract class App<S extends $Space, Modules extends string = ModuleName<S> & string, Providers extends Record<string, any> = Record<string, any>> {
+    name: string;
+    protected _config: AnyAppConfig;
+    protected _spaceModuleNames: ModuleName<S>[];
+    protected _injectedModules: AnyModule[];
+    protected _providers: Record<string, AnyAppProvider>;
+    protected space?: Space<S>;
+    protected builders?: AnyBuilder[];
+    constructor(name: string, boot?: {
+        space: Space<S>;
+    } | {
+        builders: AnyBuilder[];
+    });
+    /**
+     * Scan the space for modules and their elements,
+     * then build all schemas.
+     * This can be run without await before the daemon,
+     * to preload the module in background.
+     */
+    abstract boot(): App<S, Modules, Providers>;
+    /**
+     * Spawn a daemon for this app.
+     */
+    abstract daemon(): Promise<Daemon<S, Modules>>;
+    /**
+     * Specifies which `Space` modules to include on this App.
+     *
+     * ⚠ This has no effect on apps without a `Space`, such as `InlineApp`.
+     * @param modules A list of names of modules from the current `Space`.
+     */
+    modules<M extends ModuleName<S>>(modules: M[]): App<S, M & Modules, Providers>;
+    /**
+     * Injects pre-built modules into this App.
+     * These will be included on the Daemon once it starts.
+     *
+     * @param modules A list of pre-built modules.
+     */
+    inject(modules: AnyModule[]): this;
+    /**
+     * Declares a `Provider` with a given name.
+     *
+     * Providers are started and ended along with the daemon, and can be used on the App
+     * config to share globals between adapters and other methods.
+     * @param $ `AppProvider` with an `up` and `down` method to create/destroy the provider.
+     */
+    provider<Name extends string, T>($: AppProvider<Name, T>): App<S, Modules, Providers & { [K in Name]: T; }>;
+    get config(): AppConfigFactory<S, Modules, Providers>;
+    protected makeModules(): Record<string, AnyModule>;
+    static getInfo(app: AnyApp): {
+        spaceModules: (string | number | symbol)[];
+        config: AnyAppConfig;
+    };
+}
+export type AnyApp = App<any, any>;

package/lib/engine/apps/app.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.App = void 0;
+const module_1 = require("../module");
+const space_1 = require("../space");
+const app_config_1 = require("./app.config");
+/*
+    App
+*/
+class App {
+    constructor(name, boot) {
+        this.name = name;
+        this._config = {};
+        // This is a list of names to be read from the space.
+        // If the app is not booted with a space, this does nothing.
+        this._spaceModuleNames = [];
+        // A list of modules injected into the application prior to
+        // running the daemon. These will be included on the daemon
+        // once it's run.
+        this._injectedModules = [];
+        // A list of providers, which are created and destroyed
+        // along with the daemon. These are internally available for
+        // blocks - usually used by adapters.
+        this._providers = {};
+        if (boot) {
+            if ('space' in boot) {
+                this.space = boot.space;
+            }
+            else {
+                this.builders = boot.builders;
+            }
+        }
+    }
+    //
+    /**
+     * Specifies which `Space` modules to include on this App.
+     *
+     * ⚠ This has no effect on apps without a `Space`, such as `InlineApp`.
+     * @param modules A list of names of modules from the current `Space`.
+     */
+    modules(modules) {
+        this._spaceModuleNames = modules;
+        return this;
+    }
+    /**
+     * Injects pre-built modules into this App.
+     * These will be included on the Daemon once it starts.
+     *
+     * @param modules A list of pre-built modules.
+     */
+    inject(modules) {
+        this._injectedModules = modules;
+        return this;
+    }
+    /**
+     * Declares a `Provider` with a given name.
+     *
+     * Providers are started and ended along with the daemon, and can be used on the App
+     * config to share globals between adapters and other methods.
+     * @param $ `AppProvider` with an `up` and `down` method to create/destroy the provider.
+     */
+    provider($) {
+        this._providers[$.name] = $;
+        return this;
+    }
+    //
+    get config() {
+        return new app_config_1.AppConfigFactory(this);
+    }
+    // 
+    makeModules() {
+        const modules = {};
+        if (this.space) {
+            space_1.Space.scan(this.space, (name, path) => {
+                if (this._spaceModuleNames.includes(name)) {
+                    modules[name] = new module_1.Module(name, { path });
+                }
+            });
+        }
+        else {
+            const buildersByModule = {};
+            (this.builders || []).forEach(builder => {
+                const module = builder.module;
+                buildersByModule[module] || (buildersByModule[module] = []);
+                buildersByModule[module].push(builder);
+            });
+            Object.entries(buildersByModule).forEach(([name, builders]) => {
+                modules[name] = new module_1.Module(name, { builders });
+            });
+        }
+        return modules;
+    }
+    //
+    static getInfo(app) {
+        return {
+            spaceModules: app._spaceModuleNames,
+            config: app._config
+        };
+    }
+}
+exports.App = App;

package/lib/engine/apps/inline.app.d.ts

@@ -0,0 +1,48 @@
+import { $Module, $Space, ModuleName } from "../../schema";
+import { App, AppProvider } from './app';
+import { AnyTrxEngine } from '../transaction/trx_engine';
+import { AnyBuilder, AnyModule, Module } from '../module';
+import { AnyDaemon, Daemon } from '../daemon';
+export declare class InlineApp<S extends $Space, ModuleNames extends string = ModuleName<S> & string, Providers extends Record<string, any> = Record<string, any>> extends App<S, ModuleNames, Providers> {
+    protected _daemon?: Daemon<S, ModuleNames>;
+    protected _modules: Record<string, AnyModule>;
+    private packageJson?;
+    private bootPromise?;
+    constructor(name: string, builders: AnyBuilder[]);
+    modules<M extends ModuleName<S>>(modules: M[]): InlineApp<S, M & ModuleNames>;
+    provider<Name extends string, T>($: AppProvider<Name, T>): InlineApp<S, ModuleNames, Providers & { [K in Name]: T; }>;
+    boot(): InlineApp<S, ModuleNames, Providers>;
+    /**
+     * Treeshake and build modules declared for this application.
+     */
+    protected build(): Promise<void>;
+    /**
+     * Build the application, start providers and trx engines.
+     * Returns references to start a daemon.
+     */
+    protected make(): Promise<{
+        modules: Record<string, AnyModule>;
+        providers: Record<string, any>;
+        trxEngines: Record<ModuleNames, AnyTrxEngine>;
+    }>;
+    daemon(): Promise<Daemon<S, ModuleNames>>;
+    protected makeDaemon(trxEngines: Record<ModuleNames, AnyTrxEngine>, providers: Record<string, any>): AnyDaemon;
+    package(_package: Record<string, any>): this;
+    /**
+     * This method injects elements flagged as externals by referencing them
+     * from the other module directly, given this is a single-threaded App.
+     *
+     * TODO: allow overriding this behavior with adapters
+     */
+    protected linkExternals(modules: Record<string, Module<S, $Module>>): void;
+    static package(app: InlineApp<any, any>, scripts: Record<string, string>, dependencies: Record<string, string>): {
+        name: string;
+        version: string;
+        description: string;
+        main: string;
+        scripts: Record<string, string>;
+        dependencies: Record<string, string>;
+    };
+}
+export declare class InlineDaemon<S extends $Space, Modules extends ModuleName<S>> extends Daemon<S, Modules> {
+}

package/lib/engine/apps/inline.app.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InlineDaemon = exports.InlineApp = void 0;
+const app_1 = require("./app");
+const log_1 = require("../util/log");
+const trx_engine_1 = require("../transaction/trx_engine");
+const tree_1 = require("../tree");
+const daemon_1 = require("../daemon");
+class InlineApp extends app_1.App {
+    constructor(name, builders) {
+        super(name, { builders });
+        this._modules = {};
+    }
+    // Type Builder Overrides
+    modules(modules) {
+        super.modules(modules);
+        return this;
+    }
+    provider($) {
+        super.provider($);
+        return this;
+    }
+    // App abstract methods
+    boot() {
+        if (!this.bootPromise) {
+            this.bootPromise = this.build();
+        }
+        return this;
+    }
+    // Inline
+    /**
+     * Treeshake and build modules declared for this application.
+     */
+    async build() {
+        log_1.Log.info('app', this.name, 'Booting');
+        this._modules = await this.makeModules();
+        log_1.Log.debug('app', this.name, 'Building');
+        const tree = new tree_1.ModuleTree(this._modules, {
+            exclude: ['*.test.ts']
+        });
+        await tree.resolve();
+        await tree.traverse('Building', async (node) => {
+            // Inline nodes are built by their root builder
+            if (node.isInline) {
+                return;
+            }
+            const module = this._modules[node.module];
+            await module.buildNode(node, tree);
+        });
+    }
+    /**
+     * Build the application, start providers and trx engines.
+     * Returns references to start a daemon.
+     */
+    async make() {
+        if (this.space || this.builders) {
+            await this.boot().bootPromise;
+        }
+        const modules = this._modules;
+        for (const key in this._injectedModules) {
+            modules[key] = this._injectedModules[key];
+        }
+        const providers = {};
+        for (const key in this._providers) {
+            providers[key] = this._providers[key].up({
+                modules
+            });
+        }
+        log_1.Log.debug('app', this.name, 'Starting transaction engines');
+        const trxEngines = {};
+        for (const m in modules) {
+            const module = modules[m];
+            module.start(this, providers);
+            const trxConfig = this._config.trxEngine?.[m];
+            trxEngines[m] = new trx_engine_1.TrxEngine(`app:${this.name}`, module, this._config.authn, trxConfig, providers);
+        }
+        log_1.Log.debug('app', this.name, 'Linking externals');
+        this.linkExternals(modules);
+        return {
+            modules,
+            providers,
+            trxEngines
+        };
+    }
+    async daemon() {
+        if (this._daemon) {
+            return this._daemon;
+        }
+        const app = await this.make();
+        log_1.Log.debug('app', this.name, 'Spawning daemon');
+        this._daemon = this.makeDaemon(app.trxEngines, app.providers);
+        // Link daemon to modules
+        for (const m in app.modules) {
+            const module = app.modules[m];
+            module.daemon = this._daemon;
+        }
+        return this._daemon;
+    }
+    makeDaemon(trxEngines, providers) {
+        return new InlineDaemon(this.name, trxEngines, providers, this._config);
+    }
+    package(_package) {
+        this.packageJson = _package;
+        return this;
+    }
+    /**
+     * This method injects elements flagged as externals by referencing them
+     * from the other module directly, given this is a single-threaded App.
+     *
+     * TODO: allow overriding this behavior with adapters
+     */
+    linkExternals(modules) {
+        Object.values(modules).forEach(module => {
+            const buckets = module.schema.externals.buckets;
+            Object.values(buckets).forEach(bucket => {
+                module.buckets[bucket.refName] = modules[bucket.module].buckets[bucket.name];
+            });
+            const jobs = module.schema.externals.jobs;
+            Object.values(jobs).forEach(job => {
+                module.jobs[job.refName] = modules[job.module].jobs[job.name];
+            });
+            const machines = module.schema.externals.machines;
+            Object.values(machines).forEach(machine => {
+                module.machines[machine.refName] = modules[machine.module].machines[machine.name];
+            });
+        });
+    }
+    //
+    static package(app, scripts, dependencies) {
+        return {
+            'name': app.name,
+            'version': '1.0.0',
+            'description': '',
+            'main': 'index.js',
+            scripts,
+            dependencies,
+            ...(app.packageJson || {})
+        };
+    }
+}
+exports.InlineApp = InlineApp;
+class InlineDaemon extends daemon_1.Daemon {
+}
+exports.InlineDaemon = InlineDaemon;

package/lib/engine/apps/monolyth/monolyth.app.d.ts

@@ -0,0 +1,20 @@
+import { $Space, ModuleName } from "../../../schema";
+import { AppProvider } from '../app';
+import { InlineApp } from './../inline.app';
+import { AnyTrxEngine } from '../../transaction/trx_engine';
+import { Space } from '../../space';
+import { Daemon } from "../../daemon";
+export declare class MonolythApp<S extends $Space, ModuleNames extends string = ModuleName<S> & string, Providers extends Record<string, any> = Record<string, any>> extends InlineApp<S, ModuleNames, Providers> {
+    private watcher?;
+    constructor(name: string, space?: Space<S>);
+    protected _packageJson?: Record<string, any>;
+    modules<M extends ModuleName<S>>(modules: M[]): MonolythApp<S, M & ModuleNames>;
+    provider<Name extends string, T>($: AppProvider<Name, T>): MonolythApp<S, ModuleNames, Providers & { [K in Name]: T; }>;
+    daemon($?: {
+        watch?: boolean;
+    }): Promise<Daemon<S, ModuleNames>>;
+    protected makeDaemon(trxEngines: Record<ModuleNames, AnyTrxEngine>, providers: Record<string, any>): MonolythDaemon<$Space, ModuleNames>;
+    remake(): Promise<void>;
+}
+export declare class MonolythDaemon<S extends $Space, Modules extends ModuleName<S>> extends Daemon<S, Modules> {
+}

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

@@ -0,0 +1,94 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MonolythDaemon = exports.MonolythApp = void 0;
+const inline_app_1 = require("./../inline.app");
+const space_1 = require("../../space");
+const daemon_1 = require("../../daemon");
+const log_1 = require("../../util/log");
+class MonolythApp extends inline_app_1.InlineApp {
+    constructor(name, space) {
+        super(name, []);
+        this.builders = undefined;
+        this.space = space;
+    }
+    // Type Builder Overrides
+    modules(modules) {
+        super.modules(modules);
+        return this;
+    }
+    provider($) {
+        super.provider($);
+        return this;
+    }
+    // Override InlineApp abstract methods
+    async daemon($) {
+        /**
+         * When running from development environment (with Space)
+         * this flag watches file changes on the space path and
+         * reboots the modules.
+         *
+         * Dynamic imports are used here so `chokidar` can be declared
+         * as a "devDependency" instead of a "dependency".
+         */
+        if (this.space && $?.watch) {
+            Promise.resolve().then(() => __importStar(require('chokidar'))).then(({ default: chokidar }) => {
+                this.watcher = chokidar.watch(space_1.Space.path(this.space, '..', '..')); // TODO: change to .
+                this.watcher
+                    .on('change', () => {
+                    this.remake();
+                });
+            });
+        }
+        return super.daemon();
+    }
+    makeDaemon(trxEngines, providers) {
+        return new MonolythDaemon(this.name, trxEngines, providers, this._config);
+    }
+    // Reboot (from Watcher)
+    async remake() {
+        log_1.Log.warn('app', 'monolyth', `File changes detected. Remaking app '${this.name}'`);
+        if (!this._daemon) {
+            log_1.Log.error('app', 'monolyth', `Attempt to remake app ${this.name} failed: Daemon not running.`);
+            return;
+        }
+        const app = await this.make();
+        await daemon_1.Daemon.reload(this._daemon, app.trxEngines, app.providers);
+    }
+}
+exports.MonolythApp = MonolythApp;
+class MonolythDaemon extends daemon_1.Daemon {
+}
+exports.MonolythDaemon = MonolythDaemon;

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

@@ -0,0 +1,45 @@
+import { AnyTrxEngine } from '../../transaction/trx_engine';
+import { $Module } from "../../../schema";
+export type CLIData<M extends $Module, Msg extends keyof M['messages']> = Omit<M['messages'][Msg]['#raw'], '$'>;
+export declare class MonolythCLI {
+    private trxEngines;
+    private module?;
+    constructor(trxEngines: Record<string, AnyTrxEngine>);
+    run(): Promise<void>;
+    private runCmd;
+    private cmdHelp;
+    private cmdClear;
+    private cmdListModules;
+    private cmdInvokeInteractive;
+    private cmdPickModule;
+    private cmdInvoke;
+}
+export declare enum Color {
+    black = "0;30",
+    red = "0;31",
+    green = "0;32",
+    brown = "0;33",
+    blue = "0;34",
+    purple = "0;35",
+    cyan = "0;36",
+    lightgray = "0;37",
+    darkgray = "1;30",
+    lightred = "1;31",
+    lightgreen = "1;32",
+    yellow = "1;33",
+    lightblue = "1;34",
+    lightpurple = "1;35",
+    lightcyan = "1;36"
+}
+export default class Console {
+    static colored(msg: string, color: keyof typeof Color): string;
+    static select(title: string, options: string[], defaul?: number): Promise<string>;
+    static question(text: string, defaul?: string, prefix?: string): Promise<string>;
+    static waitForAnyKey(title?: string): Promise<void>;
+    static yesOrNo(text: string, defaul?: 'y' | 'n'): Promise<boolean>;
+    static step(msg: string): void;
+    static info(msg: string): void;
+    static cmd(msg: string): void;
+    static error(msg: string): void;
+    static header(module: string): void;
+}