nesoi 3.3.6 → 3.3.8

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

@@ -8,10 +8,12 @@ import { IService } from './service';
 import { CLIConfig } from '../cli/cli';
 import { BucketAdapter } from "../../elements/entities/bucket/adapters/bucket_adapter";
 import { $TrashBucket } from '../data/trash';
-import { $Bucket } from "../../elements";
+import { $Bucket } from "../../elements/entities/bucket/bucket.schema";
+import { $Message } from "../../elements/entities/message/message.schema";
 import { Overlay } from '../util/type';
 import { TrxStatus } from '../transaction/trx';
 import { NesoiObj } from '../data/obj';
+import { MessageTemplateDef } from "../../elements/entities/message/template/message_template.builder";
 export type AppModuleConfig<S extends $Space, M extends ModuleName<S>, Services extends Record<string, IService>> = {
     buckets?: AppBucketConfig<S, M, Services>;
     trash?: AppTrashConfig<Services>;
@@ -19,6 +21,8 @@ export type AppModuleConfig<S extends $Space, M extends ModuleName<S>, Services
     trx?: TrxEngineConfig<S, S['modules'][M], any, Services>;
 };
 export type AppConfig<S extends $Space, Modules extends ModuleName<S>, Services extends Record<string, IService>> = {
+    env?: $Message;
+    dotenv?: string;
     auth?: AppAuthConfig<S>;
     modules?: Partial<{
         [M in (Modules & keyof S['modules'])]: AppModuleConfig<S, M, Services>;
@@ -67,6 +71,8 @@ export declare class AppConfigBuilder<S extends $Space, Modules extends string =
     private app;
     private config;
     constructor(app: _App);
+    env(def: MessageTemplateDef<S, any, '__env__'>): _App;
+    dotenv(filename?: string): _App;
     auth(config: AppAuthConfig<S>): _App;
     module<M extends Modules>(name: M, config: AppModuleConfig<S, M, Services>): _App;
     audit(config: AppI18nConfig): _App;

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

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AppConfigBuilder = void 0;
+const message_builder_1 = require("../../elements/entities/message/message.builder");
+const dependency_1 = require("../dependency");
+const tree_1 = require("../tree");
 /**
  * Factory
  */
@@ -12,6 +15,23 @@ class AppConfigBuilder {
         this.app = app;
         this.config = app._config;
     }
+    env(def) {
+        const builder = new message_builder_1.MessageBuilder('__app__', '__env__')
+            .template(def);
+        const schema = message_builder_1.MessageBuilder.build({
+            builder,
+            dependencies: [],
+            filepath: '',
+            inlines: {},
+            tag: new dependency_1.Tag('__app__', 'message', '__env__'),
+        }, new tree_1.ModuleTree({}), {});
+        this.config.env = schema;
+        return this.app;
+    }
+    dotenv(filename = '.env') {
+        this.config.dotenv = filename;
+        return this.app;
+    }
     auth(config) {
         this.config.auth = config;
         return this.app;

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

@@ -31,7 +31,9 @@ export declare abstract class App<S extends $Space, Modules extends string = Mod
     /**
      * Spawn a daemon for this app.
      */
-    abstract daemon(): Promise<Daemon<S, Modules>>;
+    abstract daemon($?: {
+        dotenv?: string;
+    }): Promise<Daemon<S, Modules>>;
     /**
      * Specifies which `Space` modules to include on this App.
      *

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

@@ -24,14 +24,20 @@ export declare class InlineApp<S extends $Space, ModuleNames extends string = Mo
      * Build the application, start services and trx engines.
      * Returns references to start a daemon.
      */
-    protected make(): Promise<{
+    protected make(dotenv?: string): Promise<{
         modules: Record<string, AnyModule>;
         services: Record<string, any>;
         trxEngines: Record<ModuleNames, AnyTrxEngine>;
     }>;
-    daemon(): Promise<Daemon<S, ModuleNames>>;
+    daemon($?: {
+        dotenv?: string;
+    }): Promise<Daemon<S, ModuleNames>>;
     protected makeDaemon(trxEngines: Record<ModuleNames, AnyTrxEngine>, services: Record<string, IService>): AnyDaemon;
     package(_package: Record<string, any>): this;
+    /**
+     * This method validates the environment using the app env validator.
+     */
+    protected validateEnv(): Promise<void>;
     /**
      * This method injects values from environment variables into each module's
      * app constants.

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

@@ -13,6 +13,9 @@ const app_config_1 = require("./app.config");
 const promise_1 = __importDefault(require("../util/promise"));
 const dependency_1 = require("../dependency");
 const builder_1 = require("../builder");
+const message_template_parser_1 = require("../../elements/entities/message/template/message_template_parser");
+const trx_node_1 = require("../transaction/trx_node");
+const dotenv_1 = require("../util/dotenv");
 /**
  * @category App
  */
@@ -53,7 +56,7 @@ class InlineApp extends app_1.App {
      * Build the application, start services and trx engines.
      * Returns references to start a daemon.
      */
-    async make() {
+    async make(dotenv) {
         if (this.space || this.builders) {
             await this.boot().bootPromise;
         }
@@ -62,9 +65,21 @@ class InlineApp extends app_1.App {
             const mod = this._injectedModules[key];
             modules[mod.name] = mod;
         }
+        dotenv = dotenv || this._config.dotenv;
+        if (dotenv) {
+            log_1.Log.debug('app', this.name, `Loading environment variables from ${dotenv}`);
+            dotenv_1.DotEnv.load(dotenv);
+        }
+        if (this._config.env) {
+            log_1.Log.debug('app', this.name, 'Validating environment variables');
+            await this.validateEnv();
+        }
+        log_1.Log.debug('app', this.name, 'Linking app values');
+        this.linkAppValues(modules);
         const services = {};
         for (const key in this._services) {
             const service = this._services[key];
+            service.config = service.configFn();
             await promise_1.default.solve(service.up({
                 modules
             }));
@@ -85,21 +100,17 @@ class InlineApp extends app_1.App {
             }
             trxEngines[m] = new trx_engine_1.TrxEngine(`app:${this.name}`, module, authnProviders, trxConfig, services);
         }
-        // Log.debug('app', this.name, 'Injecting external constants and messages');
-        // this.linkExternals(modules);
-        log_1.Log.debug('app', this.name, 'Linking app values');
-        this.linkAppValues(modules);
         return {
             modules,
             services,
             trxEngines
         };
     }
-    async daemon() {
+    async daemon($) {
         if (this._daemon) {
             return this._daemon;
         }
-        const app = await this.make();
+        const app = await this.make($?.dotenv);
         log_1.Log.debug('app', this.name, 'Spawning daemon');
         this._daemon = this.makeDaemon(app.trxEngines, app.services);
         // Link daemon to modules
@@ -107,12 +118,6 @@ class InlineApp extends app_1.App {
             const module = app.modules[m];
             module.daemon = this._daemon;
         }
-        // Run init method of services
-        for (const key in app.services) {
-            await promise_1.default.solve(app.services[key].init({
-                daemon: this._daemon
-            }));
-        }
         return this._daemon;
     }
     makeDaemon(trxEngines, services) {
@@ -122,27 +127,21 @@ class InlineApp extends app_1.App {
         this.packageJson = _package;
         return this;
     }
-    // /**
-    //  * This method injects elements flagged as externals by referencing them
-    //  * from the other module directly, given this is a single-threaded App.
-    //  * 
-    //  * TODO: allow overriding this behavior with adapters
-    //  */
-    // protected linkExternals(modules: Record<string, Module<S, $Module>>) {
-    //     Object.values(modules).forEach(module => {
-    //         module.injectDependencies(modules, {
-    //             buckets: Object.values(module.schema.externals.buckets),
-    //             messages: Object.values(module.schema.externals.messages),
-    //             jobs: Object.values(module.schema.externals.jobs),
-    //             machines: Object.values(module.schema.externals.machines),
-    //             enums: Object.values(module.schema.externals.enums)
-    //         })
-    //         const buckets = module.schema.externals.buckets;
-    //         Object.values(buckets).forEach(bucket => {
-    //             module.nql.linkExternal(modules[bucket.module].buckets[bucket.name]);
-    //         })
-    //     })
-    // }
+    /**
+     * This method validates the environment using the app env validator.
+     */
+    async validateEnv() {
+        const env = process.env;
+        const trxNode = new trx_node_1.TrxNode('root', {}, undefined, { name: '__app__' });
+        try {
+            const parsed = await (0, message_template_parser_1.MessageTemplateFieldParser)(trxNode, this._config.env.template.fields, env);
+            Object.assign(process.env, parsed);
+        }
+        catch (e) {
+            log_1.Log.error('app', this.name, 'Environment variables missing or incorrect.', e);
+            throw new Error('Environment variables missing or incorrect.');
+        }
+    }
     /**
      * This method injects values from environment variables into each module's
      * app constants.

package/lib/engine/app/native/browser.app.d.ts

@@ -15,6 +15,7 @@ export declare class BrowserApp<S extends $Space, ModuleNames extends string = M
     protected _packageJson?: Record<string, any>;
     daemon($?: {
         watch?: boolean;
+        dotenv?: string;
     }): Promise<import("../../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>;

package/lib/engine/app/native/browser.app.js

@@ -17,7 +17,7 @@ class BrowserApp extends inline_app_1.InlineApp {
     }
     // Override InlineApp abstract methods
     async daemon($) {
-        return super.daemon();
+        return super.daemon($);
     }
     makeDaemon(trxEngines, services) {
         return new BrowserDaemon(this.name, trxEngines, services, this._config);

package/lib/engine/app/native/distributed_node.app.js

@@ -61,6 +61,7 @@ class DistributedNodeApp extends app_1.App {
         const services = {};
         for (const key in this._services) {
             const service = this._services[key];
+            service.config = service.configFn();
             await promise_1.default.solve(service.up({
                 modules
             }));
@@ -117,12 +118,6 @@ class DistributedNodeApp extends app_1.App {
             const module = app.modules[m];
             module.daemon = this._daemon;
         }
-        // Run init method of services
-        for (const key in app.services) {
-            await promise_1.default.solve(app.services[key].init({
-                daemon: this._daemon
-            }));
-        }
         return this._daemon;
     }
     host(config) {

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

@@ -17,6 +17,7 @@ export declare class MonolythApp<S extends $Space, ModuleNames extends string =
     protected _packageJson?: Record<string, any>;
     daemon($?: {
         watch?: boolean;
+        dotenv?: string;
     }): Promise<Daemon<S, ModuleNames>>;
     protected makeDaemon(trxEngines: Record<ModuleNames, AnyTrxEngine>, services: Record<string, IService>): MonolythDaemon<$Space, ModuleNames>;
     remake(): Promise<void>;

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

@@ -75,7 +75,7 @@ class MonolythApp extends inline_app_1.InlineApp {
                 });
             });
         }
-        return super.daemon();
+        return super.daemon($);
     }
     makeDaemon(trxEngines, services) {
         return new MonolythDaemon(this.name, trxEngines, services, this._config);

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

@@ -1,26 +1,23 @@
-import { AnyDaemon } from '../daemon';
 import { AnyModule } from '../module';
 /**
  * Service
  */
-type Optional<T> = (T extends undefined ? [] : never) | [cfg: T];
+type OptionalFn<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;
+    private configFn;
     config: Config;
     libPaths?: string[];
     abstract up($: {
         modules: Record<string, AnyModule>;
     }): void | Promise<void>;
     abstract down(): void | Promise<void>;
-    init($: {
-        daemon: AnyDaemon;
-    }): void | Promise<void>;
-    constructor(...cfg: Optional<Config>);
-    constructor(name: Name, ...cfg: Optional<Config>);
+    constructor(...cfg: OptionalFn<Config>);
+    constructor(name: Name, ...cfg: OptionalFn<Config>);
 }
 export type AnyService = Service<any, any>;
 export interface IService {
@@ -29,9 +26,6 @@ export interface IService {
     up(this: IService, $: {
         modules: Record<string, AnyModule>;
     }): void | Promise<void>;
-    init(this: IService, $: {
-        daemon: AnyDaemon;
-    }): void | Promise<void>;
     down(this: IService): void | Promise<void>;
 }
 export {};

package/lib/engine/app/service.js

@@ -2,8 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Service = void 0;
 class Service {
-    init($) {
-    }
     constructor(arg1, arg2) {
         if (typeof arg1 === 'string') {
             this.name = arg1;
@@ -11,7 +9,7 @@ class Service {
         else {
             this.name = this.constructor.defaultName;
         }
-        this.config = arg2 || arg1;
+        this.configFn = arg2 || arg1;
     }
 }
 exports.Service = Service;

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

@@ -0,0 +1,97 @@
+/**
+ * @category Engine
+ * @subcategory CLI
+ */
+export default function script<Def extends ScriptDef, T = ReturnType<Def> extends ScriptBuilder<infer X> ? X : never>(name: string, def: Def): Script<{ [K in keyof T]: T[K]; }>;
+declare class Script<T> {
+    private schema;
+    args: T;
+    constructor(schema: $Script<any>);
+    init(): T;
+    log_help(): void;
+    log_header(): void;
+    log_syntax(): void;
+    log_flags(): void;
+    error(error: string, type: 'syntax' | 'flag'): void;
+    parse(): void;
+    private parse_argv;
+    private validate;
+}
+type $Script<T> = {
+    name: string;
+    description?: string;
+    args: $ScriptArg[];
+};
+type $ScriptArg = {
+    name: string;
+    short?: string;
+    description?: string;
+    type: 'pos' | 'key';
+    values: $ScriptValue[];
+};
+type $ScriptValue = {
+    name: string;
+    description?: string;
+    type: 'string' | 'boolean' | 'enum';
+    amount: '1' | '1?' | '0+' | '1+';
+    meta: {
+        enum?: {
+            options: {
+                [x: string]: {
+                    name: string;
+                    description?: string;
+                };
+            };
+        };
+    };
+};
+type ArgName<T> = T extends `--${infer X}` ? X : T extends `-${infer X}` ? X : T;
+type ArgValue<T> = T extends Record<string, any> ? {
+    [K in keyof T]: T[K];
+} : T;
+declare class ScriptBuilder<T> {
+    private schema;
+    constructor(name: string);
+    d(description: string): this;
+    arg<Name extends string, Def extends ScriptArgDef<Name extends `-${string}` ? 'key' : 'pos'>>(name: Name, short: Name extends `-${string}` ? `-${string}` : never, def: Def): ScriptBuilder<T & {
+        [K in Name as ArgName<K>]: ReturnType<Def> extends ScriptArgBuilder<infer X> ? ArgValue<X> : any;
+    }>;
+    arg<Name extends string, Def extends ScriptArgDef<Name extends `-${string}` ? 'key' : 'pos'>>(name: Name, def: Def): ScriptBuilder<T & {
+        [K in Name as ArgName<K>]: ReturnType<Def> extends ScriptArgBuilder<infer X> ? ArgValue<X> : any;
+    }>;
+    static build<T>(builder: ScriptBuilder<T>): $Script<{ [K in keyof T]: T[K]; }>;
+}
+declare class ScriptPosArgBuilder<T = string> {
+    private schema;
+    constructor(name: string);
+    d(description: string): this;
+    value<Def extends ScriptValueDef>(def: Def): ScriptPosArgBuilder<ReturnType<Def> extends ScriptValueBuilder<infer X> ? X : never>;
+    static build(builder: ScriptPosArgBuilder): $ScriptArg;
+}
+declare class ScriptKeyArgBuilder<T = boolean | undefined> {
+    private schema;
+    constructor(name: string, short?: string);
+    d(description: string): this;
+    value<N extends string, Def extends ScriptValueDef>(name: N, def: Def): ScriptKeyArgBuilder<T extends boolean ? {
+        [k in N]: ReturnType<Def> extends ScriptValueBuilder<infer X> ? X : never;
+    } | undefined : T & {
+        [k in N]: ReturnType<Def> extends ScriptValueBuilder<infer X> ? X : never;
+    } | undefined>;
+    static build(builder: ScriptKeyArgBuilder): $ScriptArg;
+}
+declare class ScriptValueBuilder<T = string> {
+    private schema;
+    constructor(name: string);
+    d(description: string): this;
+    get optional(): ScriptValueBuilder<T | undefined>;
+    get zero_or_more(): this;
+    get one_or_more(): this;
+    get boolean(): ScriptValueBuilder<boolean>;
+    enum<E extends string>(options: E[] | Record<E, string>): ScriptValueBuilder<undefined extends T ? E | undefined : E>;
+    private build;
+}
+type ScriptArgBuilder<T> = ScriptPosArgBuilder<T> | ScriptKeyArgBuilder<T>;
+type ScriptDef = (builder: ScriptBuilder<{}>) => ScriptBuilder<any>;
+type ScriptValueDef = (builder: ScriptValueBuilder<string>) => ScriptValueBuilder<any>;
+type ScriptArgDef<Type extends 'key' | 'pos'> = (factory: Type extends 'pos' ? ScriptPosArgBuilder : ScriptKeyArgBuilder) => ScriptArgBuilder<any>;
+export {};