nesoi 3.1.7 → 3.2.1

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

@@ -1,52 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AppConfigFactory = void 0;
+exports.AppConfigBuilder = void 0;
 /**
  * Factory
  */
 /**
  * @category App
  */
-class AppConfigFactory {
+class AppConfigBuilder {
     constructor(app) {
         this.app = app;
         this.config = app._config;
     }
-    i18n(config) {
-        this.config.i18n = config;
-        return this.app;
-    }
     authn(config) {
         this.config.authn = config;
         return this.app;
     }
-    buckets(config) {
-        this.config.buckets = config;
-        return this.app;
-    }
-    trash(config) {
-        this.config.trash = config;
-        return this.app;
-    }
-    controllers(config) {
-        this.config.controllers = config;
+    module(name, config) {
+        var _a;
+        (_a = this.config).modules ?? (_a.modules = {});
+        this.config.modules[name] = config;
         return this.app;
     }
     audit(config) {
         this.config.i18n = config;
         return this.app;
     }
-    compiler(config) {
-        this.config.compiler = config;
+    i18n(config) {
+        this.config.i18n = config;
         return this.app;
     }
     cli(config) {
         this.config.cli = config;
         return this.app;
     }
-    trx(config) {
-        this.config.trxEngine = config;
+    compiler(config) {
+        this.config.compiler = config;
         return this.app;
     }
 }
-exports.AppConfigFactory = AppConfigFactory;
+exports.AppConfigBuilder = AppConfigBuilder;

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

@@ -2,8 +2,9 @@ import { $Space, ModuleName } from "../../schema";
 import { AnyBuilder, AnyModule } from '../module';
 import { Space } from '../space';
 import { Daemon } from '../daemon';
-import { AnyAppConfig, AppConfigFactory } from './app.config';
+import { AnyAppConfig, AppConfigBuilder } from './app.config';
 import { IService } from './service';
+import { DistributedAppConfigBuilder } from './distributed/distributed.app.config';
 /**
  * @category App
  */
@@ -37,14 +38,14 @@ export declare abstract class App<S extends $Space, Modules extends string = Mod
      * ⚠ 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, Services>;
+    protected modules<M extends ModuleName<S>>(modules: M[]): App<S, M & Modules, Services>;
     /**
      * 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;
+    protected inject(modules: AnyModule[]): this;
     /**
      * Declares a `Service`.
      *
@@ -52,8 +53,8 @@ export declare abstract class App<S extends $Space, Modules extends string = Mod
      * config to share globals between adapters and other methods.
      * @param $ object with an `up` and `down` method to create/destroy the service
      */
-    service<T extends IService>($: T): App<S, Modules, Services & { [K in T["name"]]: T; }>;
-    get config(): AppConfigFactory<S, Modules, Services>;
+    protected service<T extends IService>($: T): App<S, Modules, Services & { [K in T["name"]]: T; }>;
+    protected get config(): AppConfigBuilder<S, Modules, Services> | DistributedAppConfigBuilder<S, any, Modules, Services>;
     protected makeModules(): Record<string, AnyModule>;
     static getServices(app: AnyApp): Record<string, IService>;
     static getInfo(app: AnyApp): {

package/lib/engine/apps/app.js

@@ -68,7 +68,7 @@ class App {
     }
     //
     get config() {
-        return new app_config_1.AppConfigFactory(this);
+        return new app_config_1.AppConfigBuilder(this);
     }
     // 
     makeModules() {

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

@@ -0,0 +1,44 @@
+import { $Space, ModuleName } from "../../../schema";
+import { CompilerConfig } from "../../../compiler/compiler";
+import { AppAuthnConfig, AppI18nConfig, AppConfig, AppControllerConfig, AppTrashConfig } from '../app.config';
+import { CLIConfig } from "../../cli/cli";
+import { IService } from '../service';
+import { DistributedAppNode } from './distributed_node.app';
+import { TrxEngineConfig } from "../../transaction/trx_engine.config";
+import { BucketConfig } from "../../../elements/entities/bucket/bucket.config";
+export type DistributedAppModuleConfig<S extends $Space, M extends ModuleName<S>, Nodes extends Record<string, DistributedAppNode<any, any, any, any>>, Services extends Record<string, IService>> = {
+    buckets?: DistributedAppBucketConfig<S, M, Nodes, Services>;
+    jobs?: DistributedAppJobConfig<S, M, Nodes>;
+    trash?: AppTrashConfig<Services>;
+    controllers?: AppControllerConfig<S, M, Services>;
+    trx?: TrxEngineConfig<S, S['modules'][M], any, Services>;
+};
+export type DistributedAppConfig<S extends $Space, Modules extends ModuleName<S>, Nodes extends Record<string, DistributedAppNode<any, any, any, any>>, Services extends Record<string, IService>> = {
+    authn?: AppAuthnConfig<S>;
+    modules?: Partial<{
+        [M in (Modules & keyof S['modules'])]: DistributedAppModuleConfig<S, M, Nodes, Services>;
+    }>;
+    i18n?: AppI18nConfig;
+    cli?: CLIConfig<any>;
+    compiler?: CompilerConfig;
+};
+export type AnyAppConfig = AppConfig<any, any, any>;
+export type DistributedAppBucketConfig<S extends $Space, M extends keyof S['modules'], Nodes extends Record<string, DistributedAppNode<any, any, any, any>>, Services extends Record<string, IService>> = Partial<{
+    [K in keyof S['modules'][M]['buckets']]: keyof Nodes | BucketConfig<S['modules'][M], S['modules'][M]['buckets'][K], Services>;
+}>;
+export type DistributedAppJobConfig<S extends $Space, M extends keyof S['modules'], Nodes extends Record<string, DistributedAppNode<any, any, any, any>>> = Partial<{
+    [K in keyof S['modules'][M]['jobs']]: keyof Nodes;
+}>;
+/**
+ * @category DistributedApp
+ */
+export declare class DistributedAppConfigBuilder<S extends $Space, Nodes extends Record<string, DistributedAppNode<any, any, any, any>>, Modules extends string = ModuleName<S> & string, Services extends Record<string, any> = Record<string, any>> {
+    private node;
+    constructor(node: DistributedAppNode<S, Nodes, Modules, Services>);
+    authn(config: AppAuthnConfig<S>): DistributedAppNode<S, Nodes, Modules, Services>;
+    module<M extends Modules>(name: M, config: DistributedAppModuleConfig<S, M, Nodes, Services>): DistributedAppNode<S, Nodes, Modules, Services>;
+    audit(config: AppI18nConfig): DistributedAppNode<S, Nodes, Modules, Services>;
+    i18n(config: AppI18nConfig): DistributedAppNode<S, Nodes, Modules, Services>;
+    cli(config: CLIConfig<Services>): DistributedAppNode<S, Nodes, Modules, Services>;
+    compiler(config: CompilerConfig): DistributedAppNode<S, Nodes, Modules, Services>;
+}

package/lib/engine/apps/distributed/distributed.app.config.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DistributedAppConfigBuilder = void 0;
+/**
+ * @category DistributedApp
+ */
+class DistributedAppConfigBuilder {
+    constructor(node) {
+        this.node = node;
+    }
+    authn(config) {
+        // TODO
+        return this.node;
+    }
+    module(name, config) {
+        // TODO
+        return this.node;
+    }
+    audit(config) {
+        // TODO
+        return this.node;
+    }
+    i18n(config) {
+        // TODO
+        return this.node;
+    }
+    cli(config) {
+        // TODO
+        return this.node;
+    }
+    compiler(config) {
+        // TODO
+        return this.node;
+    }
+}
+exports.DistributedAppConfigBuilder = DistributedAppConfigBuilder;

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

@@ -0,0 +1,30 @@
+import { $Space } from "../../../schema";
+import { Space } from '../../space';
+import { Daemon } from "../../daemon";
+import { DistributedAppConfig } from './distributed.app.config';
+import { App } from '../app';
+import { DistributedAppNode, DistributedAppNodeDef, DistributedNodeDaemon } from './distributed_node.app';
+/**
+ * @category App
+ * @subcategory Distributed
+ */
+export declare class DistributedApp<S extends $Space, Name extends string, Nodes extends Record<string, DistributedAppNode<any, any, any, any>> = {}> extends App<S, never, never> {
+    nodes: Nodes;
+    constructor(name: Name, space?: Space<S>);
+    boot(): DistributedApp<S, Name, Nodes>;
+    daemon(): Promise<DistributedDaemon<S, { [N in keyof Nodes as `${Name}-${N & string}`]: Nodes[N]; }>>;
+    node<N extends string, ModuleNames extends string, Services extends Record<string, any>, Def extends DistributedAppNodeDef<S, Nodes, ModuleNames, Services>>(name: N, def: Def): DistributedApp<S, Name, Nodes & {
+        [K in N]: ReturnType<Def>;
+    }>;
+}
+/**
+ * @category App
+ * @subcategory Distributed
+ */
+export declare class DistributedDaemon<S extends $Space, Nodes extends Record<string, DistributedAppNode<any, any, any, any>>> extends Daemon<S, never> {
+    nodes: {
+        [K in keyof Nodes]: DistributedNodeDaemon<S, Nodes[K] extends DistributedAppNode<any, any, infer X, any> ? X : never>;
+    };
+    constructor(name: string, config: DistributedAppConfig<any, any, any, any>);
+    boot(nodes: Nodes): Promise<void>;
+}

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DistributedDaemon = exports.DistributedApp = void 0;
+const daemon_1 = require("../../daemon");
+const app_1 = require("../app");
+const distributed_node_app_1 = require("./distributed_node.app");
+/**
+ * @category App
+ * @subcategory Distributed
+ */
+class DistributedApp extends app_1.App {
+    constructor(name, space) {
+        super(name, { builders: [] });
+        this.nodes = {};
+        this.builders = undefined;
+        this.space = space;
+    }
+    // Override App abstract methods
+    boot() {
+        return this;
+    }
+    async daemon() {
+        const config = this._config;
+        const daemon = new DistributedDaemon(this.name, config);
+        await daemon.boot(this.nodes);
+        return daemon;
+    }
+    // Type Builder Overrides
+    node(name, def) {
+        let node = new distributed_node_app_1.DistributedAppNode(`${this.name}-${name}`, this.space);
+        node = def(node);
+        this.nodes[node.name] = node;
+        return this;
+    }
+}
+exports.DistributedApp = DistributedApp;
+/**
+ * @category App
+ * @subcategory Distributed
+ */
+class DistributedDaemon extends daemon_1.Daemon {
+    constructor(name, config) {
+        super(name, {}, {}, config);
+        this.nodes = {};
+    }
+    async boot(nodes) {
+        for (const name in nodes) {
+            this.nodes[name] = await nodes[name].daemon();
+        }
+    }
+}
+exports.DistributedDaemon = DistributedDaemon;

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

@@ -0,0 +1,67 @@
+import { $Module, $Space, ModuleName } from "../../../schema";
+import { IService } from '../service';
+import { DistributedAppConfig, DistributedAppConfigBuilder } from './distributed.app.config';
+import { App } from '../app';
+import { MonolythDaemon } from '../monolyth/monolyth.app';
+import { AnyTrxEngine } from "../../transaction/trx_engine";
+import { AnyModule, Module } from "../../module";
+import { Space } from "../../space";
+export declare class DistributedAppNode<S extends $Space, Nodes extends Record<string, DistributedAppNode<any, any, any, any>>, ModuleNames extends string, Services extends Record<string, any>> extends App<S, ModuleNames, Services> {
+    _host: {
+        host: string;
+        port: number;
+    };
+    protected _daemon?: DistributedNodeDaemon<S, ModuleNames>;
+    protected _modules: Record<string, AnyModule>;
+    protected packageJson?: Record<string, any>;
+    protected bootPromise?: Promise<void>;
+    constructor(name: string, space?: Space<S>);
+    /**
+     * Treeshake and build modules declared for this application.
+     */
+    protected build(): Promise<void>;
+    boot(): DistributedAppNode<S, Nodes, ModuleNames, Services>;
+    /**
+     * Build the application, start services and trx engines.
+     * Returns references to start a daemon.
+     */
+    protected make(): Promise<{
+        modules: Record<string, AnyModule>;
+        services: Record<string, any>;
+        trxEngines: Record<ModuleNames, AnyTrxEngine>;
+    }>;
+    /**
+     * 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;
+    /**
+     * This method injects values from environment variables into each module's
+     * app constants.
+     */
+    protected linkAppValues(modules: Record<string, Module<S, $Module>>): void;
+    daemon(): Promise<DistributedNodeDaemon<S, ModuleNames>>;
+    host(config: {
+        host: string;
+        port: number;
+    }): this;
+    modules<M extends ModuleName<S>>(modules: M[]): DistributedAppNode<S, Nodes, M & ModuleNames, Services>;
+    service<T extends IService>($: T): DistributedAppNode<S, Nodes, ModuleNames, Services & { [K in T["name"]]: T; }>;
+    package(_package: Record<string, any>): this;
+    get config(): DistributedAppConfigBuilder<S, Nodes, ModuleNames, Services>;
+}
+export type DistributedAppNodeDef<S extends $Space, Nodes extends Record<string, DistributedAppNode<any, any, any, any>>, ModuleNames extends string, Services extends Record<string, any>> = (builder: DistributedAppNode<S, Nodes, keyof S['modules'] & string, {}>) => DistributedAppNode<S, Nodes, ModuleNames, Services>;
+/**
+ * @category App
+ * @subcategory Distributed
+ */
+export declare class DistributedNodeDaemon<S extends $Space, Modules extends ModuleName<S>> extends MonolythDaemon<S, Modules> {
+    private inc;
+    constructor(name: string, host: {
+        host: string;
+        port: number;
+    }, trxEngines: Record<Modules, AnyTrxEngine>, services: Record<string, IService>, config?: DistributedAppConfig<any, any, any, any> | undefined);
+    boot(): Promise<void>;
+}

package/lib/engine/apps/distributed/distributed_node.app.js

@@ -0,0 +1,191 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DistributedNodeDaemon = exports.DistributedAppNode = void 0;
+const distributed_app_config_1 = require("./distributed.app.config");
+const app_1 = require("../app");
+const monolyth_app_1 = require("../monolyth/monolyth.app");
+const inc_server_1 = require("./inc/inc.server");
+const trx_engine_1 = require("../../transaction/trx_engine");
+const tree_1 = require("../../tree");
+const log_1 = require("../../util/log");
+const promise_1 = __importDefault(require("../../util/promise"));
+const distributed_job_1 = require("./elements/distributed_job");
+class DistributedAppNode extends app_1.App {
+    constructor(name, space) {
+        super(name, { builders: [] });
+        this._modules = {};
+        this.space = space;
+    }
+    /**
+     * 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);
+        });
+    }
+    boot() {
+        if (!this.bootPromise) {
+            this.bootPromise = this.build();
+        }
+        return this;
+    }
+    /**
+     * Build the application, start services 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) {
+            const mod = this._injectedModules[key];
+            modules[mod.name] = mod;
+        }
+        const services = {};
+        for (const key in this._services) {
+            const service = this._services[key];
+            await promise_1.default.solve(service.up({
+                modules
+            }));
+            services[key] = service;
+        }
+        log_1.Log.debug('app', this.name, 'Starting transaction engines');
+        const trxEngines = {};
+        for (const m in modules) {
+            const module = modules[m];
+            module.start(this, services);
+            const trxConfig = this._config.modules?.[m]?.trx;
+            const authn = {};
+            for (const a in this._config?.authn || {}) {
+                const prov = this._config.authn?.[a]?.();
+                if (prov) {
+                    authn[a] = prov;
+                }
+            }
+            trxEngines[m] = new trx_engine_1.TrxEngine(`app:${this.name}`, module, authn, trxConfig, services);
+        }
+        log_1.Log.debug('app', this.name, 'Linking externals');
+        this.linkExternals(modules);
+        log_1.Log.debug('app', this.name, 'Linking app values');
+        this.linkAppValues(modules);
+        return {
+            modules,
+            services,
+            trxEngines
+        };
+    }
+    /**
+     * 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 jobs = {};
+            for (const name in module.schema.externals.jobs) {
+                const dep = module.schema.externals.jobs[name];
+                const config = this._config;
+                const node = config?.modules?.[dep.module]?.jobs?.[dep.name];
+                if (!node) {
+                    throw new Error(`External job '${dep.tag}' not configured on module '${this.name}'`);
+                }
+                jobs[name] = new distributed_job_1.DistributedJob(module, node);
+            }
+            module.injectRunners({
+                // buckets: Object.values(module.schema.externals.buckets),
+                // messages: Object.values(module.schema.externals.messages),
+                jobs
+                // machines: Object.values(module.schema.externals.machines),
+            });
+            // const buckets = module.schema.externals.buckets;
+            // Object.values(buckets).forEach(bucket => {
+            //     module.nql.linkExternal(modules[bucket.module].buckets[bucket.name]);
+            // })
+        });
+    }
+    /**
+     * This method injects values from environment variables into each module's
+     * app constants.
+     */
+    linkAppValues(modules) {
+        Object.values(modules).forEach(module => {
+            const values = module.schema.constants.values;
+            Object.values(values).forEach(value => {
+                if (value.scope !== 'app')
+                    return;
+                value.value = process.env[value.key];
+            });
+        });
+    }
+    // Override App abstract methods
+    async daemon() {
+        if (this._daemon) {
+            return this._daemon;
+        }
+        const app = await this.make();
+        log_1.Log.debug('app', this.name, 'Spawning daemon');
+        this._daemon = new DistributedNodeDaemon(this.name, this._host, app.trxEngines, app.services, this._config);
+        await this._daemon.boot();
+        // Link daemon to modules
+        for (const m in app.modules) {
+            const module = app.modules[m];
+            module.daemon = this._daemon;
+        }
+        return this._daemon;
+    }
+    host(config) {
+        this._host = config;
+        return this;
+    }
+    modules(modules) {
+        super.modules(modules);
+        return this;
+    }
+    service($) {
+        super.service($);
+        return this;
+    }
+    package(_package) {
+        this.packageJson = _package;
+        return this;
+    }
+    get config() {
+        return new distributed_app_config_1.DistributedAppConfigBuilder(this);
+    }
+}
+exports.DistributedAppNode = DistributedAppNode;
+/**
+ * @category App
+ * @subcategory Distributed
+ */
+class DistributedNodeDaemon extends monolyth_app_1.MonolythDaemon {
+    constructor(name, host, trxEngines, services, config) {
+        super(name, trxEngines, services, config);
+        this.inc = new inc_server_1.INCServer({
+            name,
+            ...host
+        });
+    }
+    async boot() {
+        await this.inc.start();
+    }
+}
+exports.DistributedNodeDaemon = DistributedNodeDaemon;

package/lib/engine/apps/distributed/elements/distributed_job.d.ts

@@ -0,0 +1,7 @@
+import { $Job, $Module, $Space } from "../../../../elements";
+import { Job } from "../../../../elements/blocks/job/job";
+import { Module } from "../../../module";
+export declare class DistributedJob<S extends $Space, M extends $Module, $ extends $Job> extends Job<S, M, $> {
+    node: string;
+    constructor(module: Module<S, M>, node: string);
+}

package/lib/engine/apps/distributed/elements/distributed_job.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DistributedJob = void 0;
+const job_1 = require("../../../../elements/blocks/job/job");
+class DistributedJob extends job_1.Job {
+    constructor(module, node) {
+        super(module, {});
+        this.node = node;
+    }
+}
+exports.DistributedJob = DistributedJob;

package/lib/engine/apps/distributed/inc/inc.client.d.ts

@@ -0,0 +1,17 @@
+export type INCClientConfig = {
+    name: string;
+    server: {
+        host: string;
+        port: number;
+    };
+};
+export declare class INCClient {
+    config: INCClientConfig;
+    private client;
+    constructor(config: INCClientConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    send(data: string | Buffer): Promise<void>;
+    private onError;
+    private onData;
+}