nesoi 3.2.9 → 3.3.0

package/README.md

@@ -3,8 +3,39 @@ Zero-dependency Typescript framework for data-driven applications.
 
 ![Logo](/docs/header.png)
 
-> :warning: This is a work-in-progress. Breaking changes happen frequently. Once it's production-ready this notice will be removed.
+> :warning: This is a work-in-progress. Use it with caution.
+
+## Introduction
+
+**nesoi** is a framework which makes it easy to implement data operations (crud, query, hidrate), jobs (synchronous or asynchronous), statecharts, queues, topics and controllers.
+
+It does so through a _"builder-schema-element"_ paradigm, where you use _builders_ to declare _schemas_. Such _schemas_ are used by the _engine_ to build _elements_, which are runtime objects that perform actions inside _transactions_.
+
+
+> `Builder` _-builds->_ `Schema` _-configures->_ `Element`
+
+This paradigm allows declaring _modules_, which groups schemas into developer-chosen scopes. Such _modules_ are then used to declare _apps_, which are bundled ECMAScript (JS) applications.
+
+```
+modules/
+    module1/
+        ...elements...
+    module2/
+        ...elements...
+apps/
+    app1
+    app2
+```
+
+When declaring an _app_, you plug _adapters_ into the _elements_, which allows them to interact with external aspects of your application, such as databases and topics. This means the schemas are agnostic and plural, allowing adapters to be changed without friction.
+
+> A particular great feature of using _adapters_ for data sources - _buckets_ - is that queries can be performed accross different types of storage with a consistent syntax: NQL.
+
+It offers a powerful engine for developing cloud or in-browser applications, and a robust plugin system for extending it's functionalities.
+
+It also allows building and testing modules in isolation, then bundling them into different architectures.
 
 ## Getting Started
 
-Check out our [Hands-On Guide](/docs/HANDS-ON.md) for more details.
+- [Hands-On Guide](/docs/HANDS-ON.md): A quick practical read with a lot of examples.
+- [Project Template](https://github.com/nesoi-org/nesoi-meta/tree/main/template): A minimal template for building a project with _nesoi_.

package/lib/bundler/browser/browser.app.d.ts

@@ -0,0 +1,32 @@
+import { $Space, ModuleName } from "../../schema";
+import { MonolythDaemon } from '../monolyth/monolyth.app';
+import { Compiler } from "../../compiler/compiler";
+import { MonolythBundlerConfig } from "../monolyth/monolyth.bundler";
+import { AppConfigBuilder } from "../../engine/app/app.config";
+import { InlineApp } from "../../engine/app/inline.app";
+import { IService } from "../../engine/app/service";
+import { Space } from "../../engine/space";
+import { AnyTrxEngine } from "../../engine/transaction/trx_engine";
+/**
+ * @category App
+ * @subcategory Browser
+ */
+export declare class BrowserApp<S extends $Space, ModuleNames extends string = ModuleName<S> & string, Services extends Record<string, any> = Record<string, any>> extends InlineApp<S, ModuleNames, Services> {
+    protected _nesoiNpmPkg: string;
+    constructor(name: string, space?: Space<S>);
+    protected _packageJson?: Record<string, any>;
+    static bundle(compiler: Compiler, appPath: string, config?: MonolythBundlerConfig): Promise<void>;
+    daemon($?: {
+        watch?: boolean;
+    }): Promise<import("../../engine/daemon").Daemon<S, ModuleNames>>;
+    protected makeDaemon(trxEngines: Record<ModuleNames, AnyTrxEngine>, services: Record<string, IService>): BrowserDaemon<$Space, ModuleNames>;
+    modules<M extends ModuleName<S>>(modules: M[]): BrowserApp<S, M & ModuleNames>;
+    service<T extends IService>($: T): BrowserApp<S, ModuleNames, Services & { [K in T["name"]]: T; }>;
+    get config(): AppConfigBuilder<S, ModuleNames, Services, typeof this>;
+}
+/**
+ * @category App
+ * @subcategory Browser
+ */
+export declare class BrowserDaemon<S extends $Space, Modules extends ModuleName<S>> extends MonolythDaemon<S, Modules> {
+}

package/lib/bundler/browser/browser.app.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserDaemon = exports.BrowserApp = void 0;
+const monolyth_app_1 = require("../monolyth/monolyth.app");
+const browser_bundler_1 = require("./browser.bundler");
+const app_config_1 = require("../../engine/app/app.config");
+const inline_app_1 = require("../../engine/app/inline.app");
+/**
+ * @category App
+ * @subcategory Browser
+ */
+class BrowserApp extends inline_app_1.InlineApp {
+    constructor(name, space) {
+        super(name, []);
+        this._nesoiNpmPkg = '@nesoi/for-browser';
+        this.builders = undefined;
+        this.space = space;
+    }
+    //
+    static bundle(compiler, appPath, config) {
+        return new browser_bundler_1.BrowserBundler(compiler, appPath, config)
+            .run();
+    }
+    // Override InlineApp abstract methods
+    async daemon($) {
+        return super.daemon();
+    }
+    makeDaemon(trxEngines, services) {
+        return new BrowserDaemon(this.name, trxEngines, services, this._config);
+    }
+    // Type Builder Overrides
+    modules(modules) {
+        super.modules(modules);
+        return this;
+    }
+    service($) {
+        super.service($);
+        return this;
+    }
+    get config() {
+        return new app_config_1.AppConfigBuilder(this);
+    }
+}
+exports.BrowserApp = BrowserApp;
+/**
+ * @category App
+ * @subcategory Browser
+ */
+class BrowserDaemon extends monolyth_app_1.MonolythDaemon {
+}
+exports.BrowserDaemon = BrowserDaemon;

package/lib/bundler/browser/browser.bundler.d.ts

@@ -0,0 +1,5 @@
+import { MonolythBundler } from '../monolyth/monolyth.bundler';
+export declare class BrowserBundler extends MonolythBundler {
+    tsconfig: Record<string, string | number>;
+    run(): Promise<void>;
+}

package/lib/bundler/browser/browser.bundler.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserBundler = void 0;
+const typescript_1 = __importDefault(require("typescript"));
+const monolyth_bundler_1 = require("../monolyth/monolyth.bundler");
+const console_1 = __importDefault(require("../../engine/util/console"));
+const log_1 = require("../../engine/util/log");
+const _8_replace_nesoi_for_browser_stage_1 = require("./stages/8_replace_nesoi_for_browser_stage");
+class BrowserBundler extends monolyth_bundler_1.MonolythBundler {
+    constructor() {
+        super(...arguments);
+        this.tsconfig = {
+            module: typescript_1.default.ModuleKind.ESNext,
+            moduleResolution: typescript_1.default.ModuleResolutionKind.Bundler,
+        };
+    }
+    async run() {
+        await super.run();
+        console_1.default.header('Browser Bundler');
+        log_1.Log.info('bundler', 'browser', `Importing the monolyth definition from ${this.appPath}`);
+        await new _8_replace_nesoi_for_browser_stage_1.ReplaceNesoiForBrowserStage(this).run();
+    }
+}
+exports.BrowserBundler = BrowserBundler;

package/lib/bundler/browser/stages/8_replace_nesoi_for_browser_stage.d.ts

@@ -0,0 +1,13 @@
+import { BrowserBundler } from '../browser.bundler';
+/**
+ * [Browser Compiler Stage #8]
+ * Replace 'nesoi' imports by '@nesoi/for-browser'
+ *
+ * @category Monolyth Compiler
+ * @subcategory Stages
+ */
+export declare class ReplaceNesoiForBrowserStage {
+    private bundler;
+    constructor(bundler: BrowserBundler);
+    run(): Promise<void>;
+}

package/lib/bundler/browser/stages/8_replace_nesoi_for_browser_stage.js

@@ -0,0 +1,74 @@
+"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.ReplaceNesoiForBrowserStage = void 0;
+const fs = __importStar(require("fs"));
+const log_1 = require("../../../engine/util/log");
+const path_1 = require("../../../engine/util/path");
+/**
+ * [Browser Compiler Stage #8]
+ * Replace 'nesoi' imports by '@nesoi/for-browser'
+ *
+ * @category Monolyth Compiler
+ * @subcategory Stages
+ */
+class ReplaceNesoiForBrowserStage {
+    constructor(bundler) {
+        this.bundler = bundler;
+    }
+    async run() {
+        log_1.Log.info('compiler', 'browser', 'Replacing \'nesoi\' imports by \'@nesoi/for-browser\'');
+        const { dirs } = this.bundler;
+        const files = path_1.Path.allFiles(dirs.build).map(path => ({
+            path,
+            content: fs.readFileSync(path).toString()
+        }));
+        // import ... from 'nesoi/...
+        for (const file of files) {
+            if (file.content.match(/import.*from ['"]nesoi\//)) {
+                file.content = file.content.replace(/(import.*from ['"])nesoi\//g, '$1@nesoi/for-browser/');
+                fs.writeFileSync(file.path, file.content);
+            }
+        }
+        // await import('nesoi/...
+        for (const file of files) {
+            if (file.content.match(/await import\(['"]nesoi\//)) {
+                file.content = file.content.replace(/(await import\(['"])nesoi\//g, '$1@nesoi/for-browser/');
+                fs.writeFileSync(file.path, file.content);
+            }
+        }
+    }
+}
+exports.ReplaceNesoiForBrowserStage = ReplaceNesoiForBrowserStage;

package/lib/bundler/distributed/distributed.app.config.d.ts

@@ -0,0 +1,43 @@
+import { $Space, ModuleName } from "../../schema";
+import { AppConfig, AppControllerConfig, AppI18nConfig, AppTrashConfig, AppAuthConfig, CompilerConfig } from "../../engine/app/app.config";
+import { CLIConfig } from "../../engine/cli/cli";
+import { DistributedNodeApp } from './distributed_node.app';
+import { TrxEngineConfig } from "../../engine/transaction/trx_engine.config";
+import { BucketConfig } from "../../elements/entities/bucket/bucket.config";
+import { IService } from "../../engine/app/service";
+export type DistributedAppModuleConfig<S extends $Space, M extends ModuleName<S>, Nodes extends Record<string, DistributedNodeApp<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, DistributedNodeApp<any, any, any, any>>, Services extends Record<string, IService>> = {
+    auth?: AppAuthConfig<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, DistributedNodeApp<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, DistributedNodeApp<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, DistributedNodeApp<any, any, any, any>>, Modules extends string = ModuleName<S> & string, Services extends Record<string, any> = Record<string, any>> {
+    private node;
+    constructor(node: DistributedNodeApp<S, Nodes, Modules, Services>);
+    auth(config: AppAuthConfig<S>): DistributedNodeApp<S, Nodes, Modules, Services>;
+    module<M extends Modules>(name: M, config: DistributedAppModuleConfig<S, M, Nodes, Services>): DistributedNodeApp<S, Nodes, Modules, Services>;
+    audit(config: AppI18nConfig): DistributedNodeApp<S, Nodes, Modules, Services>;
+    i18n(config: AppI18nConfig): DistributedNodeApp<S, Nodes, Modules, Services>;
+    cli(config: CLIConfig<Services>): DistributedNodeApp<S, Nodes, Modules, Services>;
+    compiler(config: CompilerConfig): DistributedNodeApp<S, Nodes, Modules, Services>;
+}

package/lib/{engine/apps → bundler}/distributed/distributed.app.config.js

@@ -8,7 +8,7 @@ class DistributedAppConfigBuilder {
     constructor(node) {
         this.node = node;
     }
-    authn(config) {
+    auth(config) {
         // TODO
         return this.node;
     }

package/lib/{engine/apps → bundler}/distributed/distributed.app.d.ts

@@ -1,17 +1,21 @@
-import { $Space } from "../../../schema";
-import { Space } from '../../space';
-import { Daemon } from "../../daemon";
+import { $Space } from "../../schema";
+import { Space } from "../../engine/space";
+import { Daemon } from "../../engine/daemon";
 import { DistributedAppConfig } from './distributed.app.config';
-import { App } from '../app';
-import { DistributedAppNode, DistributedAppNodeDef, DistributedNodeDaemon } from './distributed_node.app';
-import { AnyElementSchema } from "../../module";
+import { App } from "../../engine/app/app";
+import { DistributedNodeApp, DistributedAppNodeDef, DistributedNodeDaemon } from './distributed_node.app';
+import { AnyElementSchema } from "../../engine/module";
+import { Compiler } from "../../compiler/compiler";
+import { Tag } from "../../engine/dependency";
+import { DistributedBundlerConfig } from './distributed.bundler';
 /**
  * @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> {
+export declare class DistributedApp<S extends $Space, Name extends string, Nodes extends Record<string, DistributedNodeApp<any, any, any, any>> = {}> extends App<S, never, never> {
     nodes: Nodes;
     constructor(name: Name, space?: Space<S>);
+    static compile(compiler: Compiler, appPath: string, config?: DistributedBundlerConfig): Promise<void>;
     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 & {
@@ -22,14 +26,10 @@ export declare class DistributedApp<S extends $Space, Name extends string, Nodes
  * @category App
  * @subcategory Distributed
  */
-export declare class DistributedDaemon<S extends $Space, Nodes extends Record<string, DistributedAppNode<any, any, any, any>>> extends Daemon<S, never> {
-    protected getSchema(tag: {
-        module: keyof S['modules'];
-        type: string;
-        name: string;
-    }): Promise<AnyElementSchema>;
+export declare class DistributedDaemon<S extends $Space, Nodes extends Record<string, DistributedNodeApp<any, any, any, any>>> extends Daemon<S, never> {
+    protected getSchema(tag: Tag): Promise<AnyElementSchema>;
     nodes: {
-        [K in keyof Nodes]: DistributedNodeDaemon<S, Nodes[K] extends DistributedAppNode<any, any, infer X, any> ? X : never>;
+        [K in keyof Nodes]: DistributedNodeDaemon<S, Nodes[K] extends DistributedNodeApp<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 → bundler}/distributed/distributed.app.js

@@ -1,9 +1,10 @@
 "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 daemon_1 = require("../../engine/daemon");
+const app_1 = require("../../engine/app/app");
 const distributed_node_app_1 = require("./distributed_node.app");
+const distributed_bundler_1 = require("./distributed.bundler");
 /**
  * @category App
  * @subcategory Distributed
@@ -16,6 +17,10 @@ class DistributedApp extends app_1.App {
         this.space = space;
     }
     // Override App abstract methods
+    static compile(compiler, appPath, config) {
+        return new distributed_bundler_1.DistributedBundler(compiler, appPath, config)
+            .run();
+    }
     boot() {
         return this;
     }
@@ -27,7 +32,7 @@ class DistributedApp extends app_1.App {
     }
     // Type Builder Overrides
     node(name, def) {
-        let node = new distributed_node_app_1.DistributedAppNode(`${this.name}-${name}`, this.space);
+        let node = new distributed_node_app_1.DistributedNodeApp(`${this.name}-${name}`, this.space);
         node = def(node);
         this.nodes[node.name] = node;
         return this;

package/lib/{compiler/apps/distributed/distributed_compiler.d.ts → bundler/distributed/distributed.bundler.d.ts}

@@ -1,16 +1,16 @@
-import { Compiler } from "../../compiler";
-import { AnyApp } from "../../../engine/apps/app";
-import { DistributedApp } from "../../../engine/apps/distributed/distributed.app";
-export type DistributedCompilerConfig = {
+import { Compiler } from "../../compiler/compiler";
+import { AnyApp } from "../../engine/app/app";
+import { DistributedApp } from './distributed.app';
+export type DistributedBundlerConfig = {
     libPaths?: string[];
     staticPaths?: string[];
     scripts?: Record<string, string>;
     nesoiPath?: string;
 };
-export declare class DistributedCompiler {
+export declare class DistributedBundler {
     compiler: Compiler;
     appPath: string;
-    config: DistributedCompilerConfig;
+    config: DistributedBundlerConfig;
     dirs: {
         build: string;
         nodes: {
@@ -23,7 +23,7 @@ export declare class DistributedCompiler {
             };
         };
     };
-    constructor(compiler: Compiler, appPath: string, config?: DistributedCompilerConfig);
+    constructor(compiler: Compiler, appPath: string, config?: DistributedBundlerConfig);
     run(): Promise<void>;
     mergeServicePaths(app: AnyApp): void;
     expandLibPaths(): void;

package/lib/{compiler/apps/distributed/distributed_compiler.js → bundler/distributed/distributed.bundler.js}

@@ -36,11 +36,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DistributedCompiler = void 0;
+exports.DistributedBundler = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const space_1 = require("../../../engine/space");
-const console_1 = __importDefault(require("../../../engine/util/console"));
+const space_1 = require("../../engine/space");
+const console_1 = __importDefault(require("../../engine/util/console"));
 const _1_mkdir_stage_1 = require("./stages/1_mkdir_stage");
 const _2_build_typescript_stage_1 = require("./stages/2_build_typescript_stage");
 const _3_copy_types_stage_1 = require("./stages/3_copy_types_stage");
@@ -48,11 +48,11 @@ const _4_dump_modules_stage_1 = require("./stages/4_dump_modules_stage");
 // import { CopyStaticStage } from './stages/5_copy_static_stage';
 // import { DumpCLIStage } from './stages/6_dump_cli_stage';
 // import { DumpPackageJsonStage } from './stages/7_dump_package_json_stage';
-const log_1 = require("../../../engine/util/log");
-const app_1 = require("../../../engine/apps/app");
-const distributed_app_1 = require("../../../engine/apps/distributed/distributed.app");
-const path_1 = require("../../../engine/util/path");
-class DistributedCompiler {
+const log_1 = require("../../engine/util/log");
+const app_1 = require("../../engine/app/app");
+const distributed_app_1 = require("./distributed.app");
+const path_1 = require("../../engine/util/path");
+class DistributedBundler {
     constructor(compiler, appPath, config = {}) {
         this.compiler = compiler;
         this.appPath = appPath;
@@ -60,8 +60,8 @@ class DistributedCompiler {
         this.dirs = {};
     }
     async run() {
-        console_1.default.header('Distributed Compiler');
-        log_1.Log.info('compiler', 'distributed', `Importing the Distributed definition from ${this.appPath}`);
+        console_1.default.header('Distributed Bundler');
+        log_1.Log.info('bundler', 'distributed', `Importing the Distributed definition from ${this.appPath}`);
         const appFile = space_1.Space.path(this.compiler.space, this.appPath);
         const app = (await Promise.resolve(`${appFile}`).then(s => __importStar(require(s)))).default;
         this.config = Object.assign({}, app_1.App.getInfo(app).config?.compiler || {}, this.config);
@@ -118,4 +118,4 @@ class DistributedCompiler {
         return apps;
     }
 }
-exports.DistributedCompiler = DistributedCompiler;
+exports.DistributedBundler = DistributedBundler;

package/lib/{engine/apps → bundler}/distributed/distributed_node.app.d.ts

@@ -1,12 +1,13 @@
-import { $Module, $Space, ModuleName } from "../../../schema";
-import { IService } from '../service';
-import { DistributedAppConfig, DistributedAppConfigBuilder } from './distributed.app.config';
-import { App } from '../app';
+import { $Module, $Space, ModuleName } from "../../schema";
+import { AnyTrxEngine } from "../../engine/transaction/trx_engine";
+import { AnyModule, Module } from "../../engine/module";
+import { Space } from "../../engine/space";
+import { App } from "../../engine/app/app";
+import { AppConfigBuilder } from "../../engine/app/app.config";
+import { IService } from "../../engine/app/service";
 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> {
+import { DistributedAppConfig } from './distributed.app.config';
+export declare class DistributedNodeApp<S extends $Space, Nodes extends Record<string, DistributedNodeApp<any, any, any, any>>, ModuleNames extends string, Services extends Record<string, any>> extends App<S, ModuleNames, Services> {
     _host: {
         host: string;
         port: number;
@@ -20,7 +21,7 @@ export declare class DistributedAppNode<S extends $Space, Nodes extends Record<s
      * Treeshake and build modules declared for this application.
      */
     protected build(): Promise<void>;
-    boot(): DistributedAppNode<S, Nodes, ModuleNames, Services>;
+    boot(): DistributedNodeApp<S, Nodes, ModuleNames, Services>;
     /**
      * Build the application, start services and trx engines.
      * Returns references to start a daemon.
@@ -30,13 +31,6 @@ export declare class DistributedAppNode<S extends $Space, Nodes extends Record<s
         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.
@@ -47,12 +41,12 @@ export declare class DistributedAppNode<S extends $Space, Nodes extends Record<s
         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; }>;
+    modules<M extends ModuleName<S>>(modules: M[]): DistributedNodeApp<S, Nodes, M & ModuleNames, Services>;
+    service<T extends IService>($: T): DistributedNodeApp<S, Nodes, ModuleNames, Services & { [K in T["name"]]: T; }>;
     package(_package: Record<string, any>): this;
-    get config(): DistributedAppConfigBuilder<S, Nodes, ModuleNames, Services>;
+    get config(): AppConfigBuilder<S, 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>;
+export type DistributedAppNodeDef<S extends $Space, Nodes extends Record<string, DistributedNodeApp<any, any, any, any>>, ModuleNames extends string, Services extends Record<string, any>> = (builder: DistributedNodeApp<S, Nodes, keyof S['modules'] & string, {}>) => DistributedNodeApp<S, Nodes, ModuleNames, Services>;
 /**
  * @category App
  * @subcategory Distributed

package/lib/{engine/apps → bundler}/distributed/distributed_node.app.js

@@ -3,17 +3,17 @@ 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");
+exports.DistributedNodeDaemon = exports.DistributedNodeApp = void 0;
+const trx_engine_1 = require("../../engine/transaction/trx_engine");
+const tree_1 = require("../../engine/tree");
+const log_1 = require("../../engine/util/log");
+const promise_1 = __importDefault(require("../../engine/util/promise"));
+const builder_1 = require("../../engine/builder");
+const app_1 = require("../../engine/app/app");
+const inc_server_1 = require("../../engine/app/inc/inc.server");
 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 {
+const distributed_app_config_1 = require("./distributed.app.config");
+class DistributedNodeApp extends app_1.App {
     constructor(name, space) {
         super(name, { builders: [] });
         this._modules = {};
@@ -35,8 +35,8 @@ class DistributedAppNode extends app_1.App {
             if (node.isInline) {
                 return;
             }
-            const module = this._modules[node.module];
-            await module.buildNode(node, tree);
+            const module = this._modules[node.tag.module];
+            await builder_1.Builder.buildNode(module, node, tree);
         });
     }
     boot() {
@@ -72,17 +72,15 @@ class DistributedAppNode extends app_1.App {
             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]?.();
+            const authnProviders = {};
+            for (const a in this._config?.auth || {}) {
+                const prov = this._config.auth?.[a]?.();
                 if (prov) {
-                    authn[a] = prov;
+                    authnProviders[a] = prov;
                 }
             }
-            trxEngines[m] = new trx_engine_1.TrxEngine(`app:${this.name}`, module, authn, trxConfig, services);
+            trxEngines[m] = new trx_engine_1.TrxEngine(`app:${this.name}`, module, authnProviders, 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 {
@@ -91,36 +89,6 @@ class DistributedAppNode extends app_1.App {
             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.
@@ -171,7 +139,7 @@ class DistributedAppNode extends app_1.App {
         return new distributed_app_config_1.DistributedAppConfigBuilder(this);
     }
 }
-exports.DistributedAppNode = DistributedAppNode;
+exports.DistributedNodeApp = DistributedNodeApp;
 /**
  * @category App
  * @subcategory Distributed