nesoi 3.0.9 → 3.0.11

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,7 @@ 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
  */
@@ -44,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() {
@@ -56,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 || {}) {
@@ -77,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
         };
     }
@@ -93,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];
@@ -101,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;
@@ -116,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
@@ -136,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,5 +1,5 @@
 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';
@@ -9,18 +9,18 @@ import { AppConfigFactory } from '../app.config';
  * @category App
  * @subcategory Monolyth
  */
-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> {
+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

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

@@ -76,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() {
@@ -86,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() {

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

@@ -13,10 +13,19 @@ export type AuthnRequest<P extends keyof any> = {
  * @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/zero.authn_provider.d.ts

@@ -9,11 +9,15 @@ type ZeroUser = {
  * @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

@@ -7,10 +7,17 @@ const authn_1 = require("./authn");
  * @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,9 +1,9 @@
 import { AnyDaemon } from '../daemon';
 import { CLIAdapter } from './cli_adapter';
-export type CLIConfig<Providers> = {
+export type CLIConfig<Services> = {
     editor?: string;
     adapters?: {
-        [x: string]: (cli: CLI, providers: Providers) => CLIAdapter;
+        [x: string]: (cli: CLI, services: Services) => CLIAdapter;
     };
 };
 /**

package/lib/engine/cli/cli.js

@@ -25,7 +25,7 @@ class CLI {
         // Build adapters
         this.adapters = {};
         Object.entries(config?.adapters || {}).forEach(([key, val]) => {
-            this.adapters[key] = val(this, 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());

package/lib/engine/cli/ui.js

@@ -142,7 +142,7 @@ class UI {
      * Ask a yes or no question and wait for the answer
      */
     static async yesOrNo(text, defaul = 'n') {
-        const answer = await this.waitForAnyKey('\n\t» ' + (0, string_1.colored)(text, 'lightblue') + (0, string_1.colored)(' [y|n]', 'lightgray'));
+        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;

package/lib/engine/daemon.d.ts

@@ -6,7 +6,7 @@ import { AnyUsers, AuthnRequest } from './auth/authn';
 import { TrxNode } from './transaction/trx_node';
 import { TrxStatus } from './transaction/trx';
 import { AnyModule } from './module';
-import { AnyAppProvider } from './apps/app';
+import { IService } from './apps/service';
 /**
  * A background process running one or more modules,
  * which runs _Transactions_ for the available elements.
@@ -18,15 +18,15 @@ import { AnyAppProvider } from './apps/app';
 export declare abstract class Daemon<S extends $Space, Modules extends ModuleName<S>> {
     protected name: string;
     protected trxEngines: Record<Modules, AnyTrxEngine>;
-    protected providers: Record<string, AnyAppProvider>;
+    protected services: Record<string, IService>;
     protected config?: AnyAppConfig | undefined;
     /**
      * @param name Name of the daemon (taken from App)
      * @param trxEngines A dictionary of Transaction Engine by module name
-     * @param providers A dictionary of App Provider by name
+     * @param services A dictionary of Service by name
      * @param config Optional `AppConfig`
      */
-    constructor(name: string, trxEngines: Record<Modules, AnyTrxEngine>, providers: Record<string, AnyAppProvider>, config?: AnyAppConfig | undefined);
+    constructor(name: string, trxEngines: Record<Modules, AnyTrxEngine>, services: Record<string, IService>, config?: AnyAppConfig | undefined);
     /**
      * Prepare a transaction to be run by the Daemon.
      *
@@ -45,32 +45,32 @@ export declare abstract class Daemon<S extends $Space, Modules extends ModuleNam
      */
     private bindControllers;
     /**
-     * Destroy the providers and transaction engines of this daemon
+     * Destroy the services and transaction engines of this daemon
      *
      * @param A `Daemon` instance
      */
-    static destroy(daemon: AnyDaemon): Promise<void>;
+    destroy(): Promise<void>;
     /**
-     * Replace the providers and transaction engines of this daemon
+     * Replace the services and transaction engines of this daemon
      * and rebind the controllers
      *
      * @param daemon A `Daemon` instance
      * @param trxEngines A dictionary of Transaction Engine by module name
-     * @param providers A dictionary of App Provider by name
+     * @param services A dictionary of Service by name
      */
-    static reload(daemon: AnyDaemon, trxEngines: Record<string, AnyTrxEngine>, providers: Record<string, any>): void;
+    reload(trxEngines: Record<Modules, AnyTrxEngine>, services: Record<string, any>): void;
     /**
      * Return a `Daemon` property.
      * This is used to read private properties.
      *
      * @param daemon A `Daemon` instance
-     * @param key A `Daemon` property `'name'|'providers'|'app'`
+     * @param key A `Daemon` property `'name'|'services'|'app'`
      * @returns The selected property
      */
     static get<T extends {
         name: string;
-        providers: Record<string, any>;
-        app: AnyAppConfig;
+        services: Record<string, any>;
+        config: AnyAppConfig;
     }, K extends keyof T>(daemon: AnyDaemon | undefined, key: K): T[K];
     /**
      * Return one module of the `Daemon` by name.

package/lib/engine/daemon.js

@@ -16,13 +16,13 @@ class Daemon {
     /**
      * @param name Name of the daemon (taken from App)
      * @param trxEngines A dictionary of Transaction Engine by module name
-     * @param providers A dictionary of App Provider by name
+     * @param services A dictionary of Service by name
      * @param config Optional `AppConfig`
      */
-    constructor(name, trxEngines, providers, config) {
+    constructor(name, trxEngines, services, config) {
         this.name = name;
         this.trxEngines = trxEngines;
-        this.providers = providers;
+        this.services = services;
         this.config = config;
         this.bindControllers();
         log_1.Log.info('daemon', name, 'Woo-ha!');
@@ -63,41 +63,41 @@ class Daemon {
         }
     }
     /**
-     * Destroy the providers and transaction engines of this daemon
+     * Destroy the services and transaction engines of this daemon
      *
      * @param A `Daemon` instance
      */
-    static async destroy(daemon) {
+    async destroy() {
         log_1.Log.info('daemon', this.name, 'Stop');
-        for (const key in daemon.providers) {
-            const provider = daemon.providers[key];
-            await provider.down(provider);
-            delete daemon.providers[key];
+        for (const key in this.services) {
+            const service = this.services[key];
+            await service.down();
+            delete this.services[key];
         }
-        for (const key in daemon.trxEngines) {
-            delete daemon.trxEngines[key];
+        for (const key in this.trxEngines) {
+            delete this.trxEngines[key];
         }
     }
     /**
-     * Replace the providers and transaction engines of this daemon
+     * Replace the services and transaction engines of this daemon
      * and rebind the controllers
      *
      * @param daemon A `Daemon` instance
      * @param trxEngines A dictionary of Transaction Engine by module name
-     * @param providers A dictionary of App Provider by name
+     * @param services A dictionary of Service by name
      */
-    static reload(daemon, trxEngines, providers) {
+    reload(trxEngines, services) {
         log_1.Log.info('daemon', this.name, 'Reloaded');
-        daemon.trxEngines = trxEngines;
-        daemon.providers = providers;
-        daemon.bindControllers();
+        this.trxEngines = trxEngines;
+        this.services = services;
+        this.bindControllers();
     }
     /**
      * Return a `Daemon` property.
      * This is used to read private properties.
      *
      * @param daemon A `Daemon` instance
-     * @param key A `Daemon` property `'name'|'providers'|'app'`
+     * @param key A `Daemon` property `'name'|'services'|'app'`
      * @returns The selected property
      */
     static get(daemon, key) {

package/lib/engine/data/duration.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @category Engine
+ * @subcategory Data
+ */
+export declare class NesoiDuration {
+    static UNITS: {
+        ms: "miliseconds";
+        milisecond: "miliseconds";
+        miliseconds: "miliseconds";
+        s: "seconds";
+        second: "seconds";
+        seconds: "seconds";
+        min: "minutes";
+        mins: "minutes";
+        minute: "minutes";
+        minutes: "minutes";
+        h: "hours";
+        hour: "hours";
+        hours: "hours";
+        d: "days";
+        day: "days";
+        days: "days";
+        w: "weeks";
+        week: "weeks";
+        weeks: "weeks";
+        month: "months";
+        months: "months";
+        y: "years";
+        year: "years";
+        years: "years";
+    };
+    value: number;
+    unit: typeof NesoiDuration.UNITS[keyof typeof NesoiDuration.UNITS];
+    constructor(value: {
+        miliseconds: number;
+    } | {
+        seconds: number;
+    } | {
+        minutes: number;
+    } | {
+        hours: number;
+    } | {
+        days: number;
+    } | {
+        weeks: number;
+    } | {
+        months: number;
+    } | {
+        years: number;
+    });
+    static fromString(value: string): NesoiDuration;
+    toString(): string;
+}

package/lib/engine/data/duration.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NesoiDuration = void 0;
+const error_1 = require("./error");
+/**
+ * @category Engine
+ * @subcategory Data
+ */
+class NesoiDuration {
+    constructor(value) {
+        this.unit = Object.keys(value)[0];
+        this.value = value[this.unit];
+    }
+    static fromString(value) {
+        const split = value.split(' ');
+        if (split.length !== 2) {
+            throw error_1.NesoiError.Data.InvalidDuration({ value });
+        }
+        const number = parseInt(split[0]);
+        if (isNaN(number)) {
+            throw error_1.NesoiError.Data.InvalidDuration({ value });
+        }
+        const unit_str = split[1];
+        const unit = NesoiDuration.UNITS[unit_str];
+        if (!unit) {
+            throw error_1.NesoiError.Data.InvalidDurationUnit({ value, unit: unit_str });
+        }
+        return new NesoiDuration({
+            [unit]: number
+        });
+    }
+    toString() {
+        return `${this.value} ${this.unit}`;
+    }
+}
+exports.NesoiDuration = NesoiDuration;
+NesoiDuration.UNITS = {
+    ms: 'miliseconds',
+    milisecond: 'miliseconds',
+    miliseconds: 'miliseconds',
+    s: 'seconds',
+    second: 'seconds',
+    seconds: 'seconds',
+    min: 'minutes',
+    mins: 'minutes',
+    minute: 'minutes',
+    minutes: 'minutes',
+    h: 'hours',
+    hour: 'hours',
+    hours: 'hours',
+    d: 'days',
+    day: 'days',
+    days: 'days',
+    w: 'weeks',
+    week: 'weeks',
+    weeks: 'weeks',
+    month: 'months',
+    months: 'months',
+    y: 'years',
+    year: 'years',
+    years: 'years',
+};

package/lib/engine/data/error.d.ts

@@ -134,6 +134,13 @@ export declare namespace NesoiError {
         function InvalidISOString($: {
             value: string;
         }): BaseError;
+        function InvalidDuration($: {
+            value: string;
+        }): BaseError;
+        function InvalidDurationUnit($: {
+            value: string;
+            unit: string;
+        }): BaseError;
         function UnsupportedDecimalPrecision($: {
             left: number;
             right: number;

package/lib/engine/data/error.js

@@ -4,7 +4,7 @@ exports.NesoiError = void 0;
 var NesoiError;
 (function (NesoiError) {
     class BaseError extends Error {
-        constructor(name, message, status = 500, data) {
+        constructor(name, message, status = 400, data) {
             super(message);
             this.name = name;
             this.status = status;
@@ -262,6 +262,14 @@ var NesoiError;
             return new BaseError('Message.Data.InvalidISOString', `'${$.value}' is not a valid ISO string`, Status.BAD_REQUEST, $);
         }
         Data.InvalidISOString = InvalidISOString;
+        function InvalidDuration($) {
+            return new BaseError('Message.Data.InvalidDuration', `'${$.value}' is not a valid duration`, Status.BAD_REQUEST, $);
+        }
+        Data.InvalidDuration = InvalidDuration;
+        function InvalidDurationUnit($) {
+            return new BaseError('Message.Data.InvalidDuration', `Invalid unit '${$.unit}' for duration '${$.value}'`, Status.BAD_REQUEST, $);
+        }
+        Data.InvalidDurationUnit = InvalidDurationUnit;
         function UnsupportedDecimalPrecision($) {
             return new BaseError('Message.Data.UnsupportedDecimalPrecision', `Decimal precision [${$.left},${$.right}]' is invalid. Supported range: 1~12.`, Status.BAD_REQUEST, $);
         }

package/lib/engine/dependency.d.ts

@@ -1,4 +1,4 @@
-import { BuilderType } from "../schema";
+import { $Module, BuilderType } from "../schema";
 import { AnyBuilder, AnyElementSchema } from './module';
 import { Overlay } from './util/type';
 import { JobBuilderNode } from "../elements/blocks/job/job.builder";
@@ -80,6 +80,7 @@ export declare class $Dependency {
      * @returns The type name of the dependency
      */
     static typeName(dep: $Dependency, fromModule: string): string;
+    static resolve(module: $Module, dep: $Dependency): import("../elements").$Message | import("../elements").$Machine | import("../elements").$Bucket | import("../elements").$Constants | import("../elements").$Job | import("../elements").$Externals | import("../elements").$Resource | import("../elements").$Controller | undefined;
 }
 /**
  * A element builder, along with metadata required for building it.