nesoi 3.0.8 → 3.0.10

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

@@ -1,31 +1,35 @@
 import { $Module, $Space, ModuleName } from "../../schema";
-import { App, AppProvider } from './app';
+import { App } from './app';
+import { IService } from './service';
 import { AnyTrxEngine } from '../transaction/trx_engine';
 import { AnyBuilder, AnyModule, Module } from '../module';
 import { AnyDaemon, Daemon } from '../daemon';
 import { AppConfigFactory } from './app.config';
-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> {
+/**
+ * @category App
+ */
+export declare class InlineApp<S extends $Space, ModuleNames extends string = ModuleName<S> & string, Services extends Record<string, any> = Record<string, any>> extends App<S, ModuleNames, Services> {
     protected _daemon?: Daemon<S, ModuleNames>;
     protected _modules: Record<string, AnyModule>;
     private packageJson?;
     protected bootPromise?: Promise<void>;
     constructor(name: string, builders: AnyBuilder[]);
-    boot(): InlineApp<S, ModuleNames, Providers>;
+    boot(): InlineApp<S, ModuleNames, Services>;
     /**
      * Treeshake and build modules declared for this application.
      */
     protected build(): Promise<void>;
     /**
-     * Build the application, start providers and trx engines.
+     * Build the application, start services and trx engines.
      * Returns references to start a daemon.
      */
     protected make(): Promise<{
         modules: Record<string, AnyModule>;
-        providers: Record<string, any>;
+        services: Record<string, any>;
         trxEngines: Record<ModuleNames, AnyTrxEngine>;
     }>;
     daemon(): Promise<Daemon<S, ModuleNames>>;
-    protected makeDaemon(trxEngines: Record<ModuleNames, AnyTrxEngine>, providers: Record<string, any>): AnyDaemon;
+    protected makeDaemon(trxEngines: Record<ModuleNames, AnyTrxEngine>, services: Record<string, IService>): AnyDaemon;
     package(_package: Record<string, any>): this;
     /**
      * This method injects elements flagged as externals by referencing them
@@ -35,8 +39,8 @@ export declare class InlineApp<S extends $Space, ModuleNames extends string = Mo
      */
     protected linkExternals(modules: Record<string, Module<S, $Module>>): void;
     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; }>;
-    get config(): AppConfigFactory<S, ModuleNames, Providers, typeof this>;
+    service<T extends IService>($: T): InlineApp<S, ModuleNames, Services & { [K in T["name"]]: T; }>;
+    get config(): AppConfigFactory<S, ModuleNames, Services, typeof this>;
     static package(app: InlineApp<any, any>, scripts: Record<string, string>, dependencies: Record<string, string>): {
         name: string;
         version: string;

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

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InlineDaemon = exports.InlineApp = void 0;
 const app_1 = require("./app");
@@ -7,6 +10,10 @@ const trx_engine_1 = require("../transaction/trx_engine");
 const tree_1 = require("../tree");
 const daemon_1 = require("../daemon");
 const app_config_1 = require("./app.config");
+const promise_1 = __importDefault(require("../util/promise"));
+/**
+ * @category App
+ */
 class InlineApp extends app_1.App {
     constructor(name, builders) {
         super(name, { builders });
@@ -41,7 +48,7 @@ class InlineApp extends app_1.App {
         });
     }
     /**
-     * Build the application, start providers and trx engines.
+     * Build the application, start services and trx engines.
      * Returns references to start a daemon.
      */
     async make() {
@@ -53,19 +60,19 @@ class InlineApp extends app_1.App {
             const mod = this._injectedModules[key];
             modules[mod.name] = mod;
         }
-        const providers = {};
-        for (const key in this._providers) {
-            const provider = this._providers[key].up({
+        const services = {};
+        for (const key in this._services) {
+            const service = this._services[key];
+            await promise_1.default.solve(service.up({
                 modules
-            });
-            provider.__down = this._providers[key].down;
-            providers[key] = provider;
+            }));
+            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, providers);
+            module.start(this, services);
             const trxConfig = this._config.trxEngine?.[m];
             const authn = {};
             for (const a in this._config?.authn || {}) {
@@ -74,13 +81,13 @@ class InlineApp extends app_1.App {
                     authn[a] = prov;
                 }
             }
-            trxEngines[m] = new trx_engine_1.TrxEngine(`app:${this.name}`, module, authn, trxConfig, providers);
+            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);
         return {
             modules,
-            providers,
+            services,
             trxEngines
         };
     }
@@ -90,7 +97,7 @@ class InlineApp extends app_1.App {
         }
         const app = await this.make();
         log_1.Log.debug('app', this.name, 'Spawning daemon');
-        this._daemon = this.makeDaemon(app.trxEngines, app.providers);
+        this._daemon = this.makeDaemon(app.trxEngines, app.services);
         // Link daemon to modules
         for (const m in app.modules) {
             const module = app.modules[m];
@@ -98,8 +105,8 @@ class InlineApp extends app_1.App {
         }
         return this._daemon;
     }
-    makeDaemon(trxEngines, providers) {
-        return new InlineDaemon(this.name, trxEngines, providers, this._config);
+    makeDaemon(trxEngines, services) {
+        return new InlineDaemon(this.name, trxEngines, services, this._config);
     }
     package(_package) {
         this.packageJson = _package;
@@ -113,19 +120,15 @@ class InlineApp extends app_1.App {
      */
     linkExternals(modules) {
         Object.values(modules).forEach(module => {
+            module.injectDependencies(modules, {
+                buckets: Object.values(module.schema.externals.buckets),
+                jobs: Object.values(module.schema.externals.jobs),
+                machines: Object.values(module.schema.externals.machines),
+            });
             const buckets = module.schema.externals.buckets;
             Object.values(buckets).forEach(bucket => {
-                module.buckets[bucket.refName] = modules[bucket.module].buckets[bucket.name];
                 module.nql.linkExternal(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];
-            });
         });
     }
     // Type Builder Overrides
@@ -133,8 +136,8 @@ class InlineApp extends app_1.App {
         super.modules(modules);
         return this;
     }
-    provider($) {
-        super.provider($);
+    service($) {
+        super.service($);
         return this;
     }
     get config() {

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

@@ -1,22 +1,30 @@
 import { $Space, ModuleName } from "../../../schema";
-import { AppProvider } from '../app';
+import { IService } from '../service';
 import { InlineApp } from './../inline.app';
 import { AnyTrxEngine } from '../../transaction/trx_engine';
 import { Space } from '../../space';
 import { Daemon } from "../../daemon";
 import { AppConfigFactory } from '../app.config';
-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> {
+/**
+ * @category App
+ * @subcategory Monolyth
+ */
+export declare class MonolythApp<S extends $Space, ModuleNames extends string = ModuleName<S> & string, Services extends Record<string, any> = Record<string, any>> extends InlineApp<S, ModuleNames, Services> {
     private watcher?;
     constructor(name: string, space?: Space<S>);
     protected _packageJson?: Record<string, any>;
     daemon($?: {
         watch?: boolean;
     }): Promise<Daemon<S, ModuleNames>>;
-    protected makeDaemon(trxEngines: Record<ModuleNames, AnyTrxEngine>, providers: Record<string, any>): MonolythDaemon<$Space, ModuleNames>;
+    protected makeDaemon(trxEngines: Record<ModuleNames, AnyTrxEngine>, services: Record<string, IService>): MonolythDaemon<$Space, ModuleNames>;
     remake(): Promise<void>;
     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; }>;
-    get config(): AppConfigFactory<S, ModuleNames, Providers, typeof this>;
+    service<T extends IService>($: T): MonolythApp<S, ModuleNames, Services & { [K in T["name"]]: T; }>;
+    get config(): AppConfigFactory<S, ModuleNames, Services, typeof this>;
 }
+/**
+ * @category App
+ * @subcategory Monolyth
+ */
 export declare class MonolythDaemon<S extends $Space, Modules extends ModuleName<S>> extends Daemon<S, Modules> {
 }

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

@@ -39,6 +39,10 @@ const space_1 = require("../../space");
 const daemon_1 = require("../../daemon");
 const log_1 = require("../../util/log");
 const app_config_1 = require("../app.config");
+/**
+ * @category App
+ * @subcategory Monolyth
+ */
 class MonolythApp extends inline_app_1.InlineApp {
     constructor(name, space) {
         super(name, []);
@@ -72,8 +76,8 @@ class MonolythApp extends inline_app_1.InlineApp {
         }
         return super.daemon();
     }
-    makeDaemon(trxEngines, providers) {
-        return new MonolythDaemon(this.name, trxEngines, providers, this._config);
+    makeDaemon(trxEngines, services) {
+        return new MonolythDaemon(this.name, trxEngines, services, this._config);
     }
     // Reboot (from Watcher)
     async remake() {
@@ -82,18 +86,18 @@ class MonolythApp extends inline_app_1.InlineApp {
             log_1.Log.error('app', 'monolyth', `Attempt to remake app ${this.name} failed: Daemon not running.`);
             return;
         }
-        await daemon_1.Daemon.destroy(this._daemon);
+        await this._daemon.destroy();
         this.bootPromise = undefined;
         const app = await this.make();
-        await daemon_1.Daemon.reload(this._daemon, app.trxEngines, app.providers);
+        await this._daemon.reload(app.trxEngines, app.services);
     }
     // Type Builder Overrides
     modules(modules) {
         super.modules(modules);
         return this;
     }
-    provider($) {
-        super.provider($);
+    service($) {
+        super.service($);
         return this;
     }
     get config() {
@@ -101,6 +105,10 @@ class MonolythApp extends inline_app_1.InlineApp {
     }
 }
 exports.MonolythApp = MonolythApp;
+/**
+ * @category App
+ * @subcategory Monolyth
+ */
 class MonolythDaemon extends daemon_1.Daemon {
 }
 exports.MonolythDaemon = MonolythDaemon;

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

@@ -0,0 +1,30 @@
+import { AnyModule } from '../module';
+/**
+ * Service
+ */
+type Optional<T> = (T extends undefined ? [] : never) | [cfg: T];
+export declare abstract class Service<out Name extends string, Config = never> {
+    /**
+     * This property MUST be set on the implementation class.
+     */
+    static defaultName: string;
+    name: Name;
+    config: Config;
+    libPaths?: string[];
+    abstract up($: {
+        modules: Record<string, AnyModule>;
+    }): void | Promise<void>;
+    abstract down(): void | Promise<void>;
+    constructor(...cfg: Optional<Config>);
+    constructor(name: Name, ...cfg: Optional<Config>);
+}
+export type AnyService = Service<any, any>;
+export interface IService {
+    name: string;
+    libPaths?: string[];
+    up(this: IService, $: {
+        modules: Record<string, AnyModule>;
+    }): void | Promise<void>;
+    down(this: IService): void | Promise<void>;
+}
+export {};

package/lib/engine/apps/service.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Service = void 0;
+class Service {
+    constructor(arg1, arg2) {
+        if (typeof arg1 === 'string') {
+            this.name = arg1;
+        }
+        else {
+            this.name = this.constructor.defaultName;
+        }
+        this.config = arg2 || arg1;
+    }
+}
+exports.Service = Service;

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

@@ -8,11 +8,24 @@ export type AuthnToken = string;
 export type AuthnRequest<P extends keyof any> = {
     [K in P]?: AuthnToken;
 };
+/**
+ * @category Engine
+ * @subcategory Auth
+ */
 export declare abstract class AuthnProvider<U extends User> {
+    /**
+     * - If `true`, this provider is run for all transactions, regardless
+     * of a token being sent on the authentication request.
+     * - If `false`, the `$.token` is always defined.
+     */
+    abstract eager: boolean;
     abstract authenticate($: {
         trx: AnyTrxNode;
+        token?: AuthnToken;
+    }): Promise<{
         token: AuthnToken;
-    }): Promise<U>;
+        user: U;
+    }>;
 }
 export type AnyAuthnProviders = {
     [K: string]: AuthnProvider<any>;

package/lib/engine/auth/authn.js

@@ -4,6 +4,10 @@ exports.AuthnProvider = void 0;
 /*
     Provider
 */
+/**
+ * @category Engine
+ * @subcategory Auth
+ */
 class AuthnProvider {
 }
 exports.AuthnProvider = AuthnProvider;

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

@@ -4,12 +4,20 @@ type ZeroUser = {
     id: NesoiObjId;
     name: string;
 };
+/**
+ * @category Engine
+ * @subcategory Auth
+ */
 export declare class ZeroAuthnProvider extends AuthnProvider<ZeroUser> {
+    eager: boolean;
     authenticate($: {
-        token: string;
+        token?: string;
     }): Promise<{
-        id: number;
-        name: string;
+        token: string;
+        user: {
+            id: number;
+            name: string;
+        };
     }>;
 }
 export {};

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

@@ -2,11 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZeroAuthnProvider = void 0;
 const authn_1 = require("./authn");
+/**
+ * @category Engine
+ * @subcategory Auth
+ */
 class ZeroAuthnProvider extends authn_1.AuthnProvider {
+    constructor() {
+        super(...arguments);
+        this.eager = false;
+    }
     authenticate($) {
         return Promise.resolve({
-            id: 0,
-            name: $.token
+            token: $.token,
+            user: {
+                id: 0,
+                name: $.token
+            }
         });
     }
 }

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

@@ -1,10 +1,15 @@
 import { AnyDaemon } from '../daemon';
 import { CLIAdapter } from './cli_adapter';
-export type CLIConfig<Providers> = {
+export type CLIConfig<Services> = {
+    editor?: string;
     adapters?: {
-        [x: string]: (providers: Providers) => CLIAdapter;
+        [x: string]: (cli: CLI, services: Services) => CLIAdapter;
     };
 };
+/**
+ * @category Engine
+ * @subcategory CLI
+ */
 export declare class CLI {
     private daemon;
     config?: CLIConfig<any> | undefined;
@@ -18,4 +23,5 @@ export declare class CLI {
     private cmdHelp;
     private cmdClear;
     private getCmds;
+    openEditor(file: string): void;
 }

package/lib/engine/cli/cli.js

@@ -10,6 +10,11 @@ const console_1 = __importDefault(require("../util/console"));
 const daemon_1 = require("../daemon");
 const log_1 = require("../util/log");
 const cli_input_1 = require("./cli_input");
+const shell_1 = __importDefault(require("../util/shell"));
+/**
+ * @category Engine
+ * @subcategory CLI
+ */
 class CLI {
     constructor(daemon, config) {
         this.daemon = daemon;
@@ -20,7 +25,7 @@ class CLI {
         // Build adapters
         this.adapters = {};
         Object.entries(config?.adapters || {}).forEach(([key, val]) => {
-            this.adapters[key] = val(daemon_1.Daemon.get(daemon, 'providers'));
+            this.adapters[key] = val(this, daemon_1.Daemon.get(daemon, 'services'));
             this.adapters[key].name = key;
         });
         this.input = new cli_input_1.CLIInputHandler(this.getCmds());
@@ -103,5 +108,9 @@ class CLI {
         }
         return cmds;
     }
+    openEditor(file) {
+        const editor = this.config?.editor || 'code';
+        shell_1.default.cmd(process.cwd(), `${editor} ${file}`);
+    }
 }
 exports.CLI = CLI;

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

@@ -1,4 +1,9 @@
 import { AnyDaemon } from '../daemon';
+import { CLI } from './cli';
+/**
+ * @category Engine
+ * @subcategory CLI
+ */
 export declare abstract class CLICommand<T extends Record<string, any> = Record<string, any>> {
     scope: 'dev' | 'prod' | 'any';
     name: string;
@@ -10,10 +15,15 @@ export declare abstract class CLICommand<T extends Record<string, any> = Record<
     input(payload: string): Record<string, any>;
     abstract run(daemon: AnyDaemon, input: T): Promise<void>;
 }
+/**
+ * @category Engine
+ * @subcategory CLI
+ */
 export declare abstract class CLIAdapter {
+    protected cli: CLI;
     name?: string;
     commands: Record<string, CLICommand>;
-    constructor();
+    constructor(cli: CLI);
     runCmd(daemon: AnyDaemon, payload: string): Promise<boolean>;
     help(): string;
 }

package/lib/engine/cli/cli_adapter.js

@@ -2,6 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CLIAdapter = exports.CLICommand = void 0;
 const string_1 = require("../util/string");
+/**
+ * @category Engine
+ * @subcategory CLI
+ */
 class CLICommand {
     constructor(scope, name, syntax, description, regex, groups) {
         this.scope = scope;
@@ -30,8 +34,13 @@ class CLICommand {
     }
 }
 exports.CLICommand = CLICommand;
+/**
+ * @category Engine
+ * @subcategory CLI
+ */
 class CLIAdapter {
-    constructor() {
+    constructor(cli) {
+        this.cli = cli;
         this.commands = {};
     }
     async runCmd(daemon, payload) {

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

@@ -1,3 +1,7 @@
+/**
+ * @category Engine
+ * @subcategory CLI
+ */
 export declare class CLIInputHandler {
     private suggestions;
     private items;

package/lib/engine/cli/cli_input.js

@@ -36,6 +36,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CLIInputHandler = void 0;
 const stream_1 = require("stream");
 const readline = __importStar(require("readline"));
+/**
+ * @category Engine
+ * @subcategory CLI
+ */
 class CLIInputHandler {
     constructor(suggestions = []) {
         this.suggestions = suggestions;

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

@@ -1,8 +1,15 @@
+/**
+ * @category Engine
+ * @subcategory CLI
+ */
 export default class UI {
     /**
      * Show a list of options and let the user pick with up/down + enter
      */
-    static select<T>(title: string, options: T[], val?: NoInfer<(o: T) => string>, defaul?: number): Promise<T>;
+    static select<T>(title: string, options: T[], val?: NoInfer<(o: T) => string>, defaul?: number): Promise<{
+        i: number;
+        value: T;
+    }>;
     /**
      * Ask a question and wait for the answer
      */
@@ -10,7 +17,12 @@ export default class UI {
     /**
      * Show a message and wait for the user to press any key
      */
-    static waitForAnyKey(title?: string): Promise<void>;
+    static waitForAnyKey(title?: string): Promise<{
+        sequence: string;
+        name: string;
+        ctrl: boolean;
+        shift: boolean;
+    }>;
     /**
      * Ask a yes or no question and wait for the answer
      */

package/lib/engine/cli/ui.js

@@ -36,6 +36,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const readline = __importStar(require("readline"));
 const stream_1 = require("stream");
 const string_1 = require("../util/string");
+/**
+ * @category Engine
+ * @subcategory CLI
+ */
 class UI {
     /**
      * Show a list of options and let the user pick with up/down + enter
@@ -85,7 +89,7 @@ class UI {
                 else if (key.name === 'return') {
                     rl.close();
                     process.stdin.off('keypress', onKeypress);
-                    resolve(options[selected]);
+                    resolve({ i: selected, value: options[selected] });
                 }
                 clear();
                 print();
@@ -115,7 +119,7 @@ class UI {
      */
     static waitForAnyKey(title = 'Press any key to continue...') {
         return new Promise(resolve => {
-            UI.step(title);
+            process.stdin.write(title + ' ');
             const mutableStdout = new stream_1.Writable({
                 write: function (chunk, encoding, callback) {
                 }
@@ -127,8 +131,9 @@ class UI {
             });
             const onKeypress = function (ch, key) {
                 rl.close();
+                console.log(`${(0, string_1.colored)(ch, 'lightcyan')}\n`);
                 process.stdin.off('keypress', onKeypress);
-                resolve();
+                resolve(key);
             };
             process.stdin.on('keypress', onKeypress);
         });
@@ -137,9 +142,8 @@ class UI {
      * 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')
+        const answer = await this.waitForAnyKey('\n\t» ' + (0, string_1.colored)(text, 'lightblue') + (0, string_1.colored)(' [y|n]', 'darkgray'));
+        if (answer.name === 'y')
             return true;
         return false;
     }