nesoi 3.3.7 → 3.3.9

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 {};

package/lib/engine/cli/script.js

@@ -0,0 +1,422 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = script;
+const string_1 = require("../util/string");
+/**
+ * @category Engine
+ * @subcategory CLI
+ */
+function script(name, def) {
+    const builder = def(new ScriptBuilder(name));
+    const schema = ScriptBuilder.build(builder);
+    return new Script(schema);
+}
+//
+class Script {
+    constructor(schema) {
+        this.schema = schema;
+        this.args = {};
+    }
+    init() {
+        if (process.argv.includes('-h') || process.argv.includes('--help')) {
+            this.log_help();
+            process.exit();
+        }
+        this.parse();
+        return this.args;
+    }
+    log_help() {
+        this.log_header();
+        this.log_syntax();
+        const pos_args = this.schema.args.filter(arg => arg.type === 'pos');
+        if (pos_args.length) {
+            console.log('Positional Arguments:\n');
+            for (const arg of pos_args) {
+                let str = ' ';
+                str += (0, string_1.colored)(arg.name, 'brown');
+                str += '\n  ';
+                if (arg.values[0].amount === '1?') {
+                    str += (0, string_1.colored)('(optional) ', 'blue');
+                }
+                else if (arg.values[0].amount === '0+') {
+                    str += (0, string_1.colored)('(zero or more) ', 'blue');
+                }
+                else if (arg.values[0].amount === '1+') {
+                    str += (0, string_1.colored)('(one or more) ', 'blue');
+                }
+                str += (0, string_1.colored)(arg.description ?? '', 'blue');
+                str += '\n';
+                if (arg.values[0].type === 'enum') {
+                    for (const opt in arg.values[0].meta.enum.options) {
+                        const option = arg.values[0].meta.enum.options[opt];
+                        str += '  - ' + (0, string_1.colored)(opt, 'lightblue') + ' ' + (0, string_1.colored)(option.description ? (': ' + option.description) : '', 'blue');
+                        str += '\n';
+                    }
+                }
+                console.log(str);
+            }
+        }
+        this.log_flags();
+    }
+    log_header() {
+        console.log();
+        console.log((0, string_1.colored)(this.schema.name, 'lightpurple'));
+        if (this.schema.description) {
+            console.log((0, string_1.colored)(this.schema.description, 'purple'));
+        }
+        console.log();
+    }
+    log_syntax() {
+        const syntax = this.schema.args.map(arg => {
+            const values = [];
+            for (const val of arg.values) {
+                switch (val.amount) {
+                    case '1':
+                        values.push(val.name);
+                        break;
+                    case '1?':
+                        values.push(val.name + '?');
+                        break;
+                    case '0+':
+                        values.push(val.name + '0..' + val.name + '+');
+                        break;
+                    case '1+':
+                        values.push(val.name + '1..' + val.name + '+');
+                        break;
+                }
+            }
+            let p = arg.name;
+            if (arg.type === 'pos') {
+                p = `{${values[0]}}`;
+            }
+            else if (arg.type === 'key') {
+                p = `[${p}${values.length ? (' ' + values.join(' ')) : ''}]`;
+            }
+            return p;
+        }).join(' ');
+        console.log(`Syntax:\n\n${(0, string_1.colored)(this.schema.name + ' ' + syntax, 'brown')}`);
+        console.log();
+    }
+    log_flags() {
+        const key_args = this.schema.args.filter(arg => arg.type === 'key');
+        console.log('Keyword Arguments:\n');
+        console.log(` ${(0, string_1.colored)('-h --help', 'cyan')}?\n  ${(0, string_1.colored)('Show this help info', 'blue')}\n`);
+        for (const arg of key_args) {
+            const values = [];
+            for (const val of arg.values) {
+                switch (val.amount) {
+                    case '1':
+                        values.push(val.name);
+                        break;
+                    case '1?':
+                        values.push(val.name + '?');
+                        break;
+                    case '0+':
+                        values.push(val.name + '0..' + val.name + '+');
+                        break;
+                    case '1+':
+                        values.push(val.name + '1..' + val.name + '+');
+                        break;
+                }
+            }
+            let str = ' ';
+            if (arg.short) {
+                str += (0, string_1.colored)(arg.short + ' ' + arg.name, 'brown');
+            }
+            else {
+                str += (0, string_1.colored)(arg.name, 'brown');
+            }
+            for (const value of values) {
+                str += ' ' + (0, string_1.colored)(value, 'green');
+            }
+            str += '\n  ';
+            str += (0, string_1.colored)(arg.description ?? '', 'blue');
+            str += '\n  ';
+            for (let i = 0; i < values.length; i++) {
+                str += (0, string_1.colored)(values[i], 'green');
+                if (arg.values[i].amount === '1?') {
+                    str += (0, string_1.colored)(': (optional)', 'cyan');
+                }
+                else if (arg.values[i].amount === '0+') {
+                    str += (0, string_1.colored)(': (zero or more)', 'cyan');
+                }
+                else if (arg.values[i].amount === '1+') {
+                    str += (0, string_1.colored)(': (one or more)', 'cyan');
+                }
+                if (arg.values[i].description) {
+                    str += (0, string_1.colored)(` ${arg.values[i].description}`, 'cyan');
+                }
+                str += '\n  ';
+            }
+            console.log(str);
+        }
+        console.log();
+    }
+    error(error, type) {
+        this.log_header();
+        if (type === 'syntax') {
+            this.log_syntax();
+        }
+        else {
+            this.log_flags();
+        }
+        console.log((0, string_1.colored)('---\n' + error + '\n---', 'red'));
+        console.log();
+        process.exit();
+    }
+    parse() {
+        const argv = process.argv;
+        let i = 2;
+        // Positional
+        for (const arg of this.schema.args) {
+            if (arg.type !== 'pos')
+                break;
+            const { i: j, value } = this.parse_argv(arg, arg.values[0], i);
+            this.args[arg.name] = value;
+            i = j;
+        }
+        // Keyword
+        let arg;
+        while (i < argv.length) {
+            if (!argv[i].startsWith('-')) {
+                this.error(`Error: Unexpected argument(s) at the end '${argv.slice(i).join(' ')}'`, 'syntax');
+            }
+            arg = this.schema.args.find(arg => arg.name === argv[i] || arg.short === argv[i]);
+            if (!arg) {
+                this.error(`Error: Unknown keyword argument '${argv[i]}'`, 'flag');
+                break;
+            }
+            const name = arg.name.replace(/-+(.*)/, '$1');
+            if (arg.values.length) {
+                this.args[name] = {};
+                i++;
+                for (const val of arg.values) {
+                    const { i: j, value } = this.parse_argv(arg, val, i);
+                    i = j;
+                    this.args[name][val.name] = value;
+                }
+            }
+            else {
+                this.args[name] = true;
+                i++;
+            }
+        }
+        // for (const arg of this.schema.args) {
+        //     if (arg.type !== 'key') continue;
+        //     if (i >= argv.length) break;
+        // }
+    }
+    parse_argv(arg, value, i) {
+        const argv = process.argv;
+        const values = [];
+        // Single
+        if (value.amount === '1' || value.amount === '1?') {
+            if (argv[i] && !argv[i].startsWith('-')) {
+                values.push(argv[i]);
+                i++;
+            }
+        }
+        // Many
+        else {
+            while (i < argv.length) {
+                if (argv[i].startsWith('-'))
+                    break;
+                values.push(argv[i]);
+                i++;
+            }
+        }
+        if (values.length === 0 && (value.amount === '1' || value.amount === '1+')) {
+            this.error(`Error: Missing required ${arg.type === 'pos' ? 'positional argument' : ('value from arg \'' + arg.name + '\' named')} '${value.name}'`, 'syntax');
+        }
+        const validated = values.map(val => this.validate(value, val));
+        // Single
+        if (value.amount === '1' || value.amount === '1?') {
+            return { value: validated[0], i };
+        }
+        else {
+            return { value: validated, i };
+        }
+    }
+    validate(schema, value) {
+        switch (schema.type) {
+            case 'string':
+                return value;
+                break;
+            case 'boolean':
+                if (value.toLowerCase() === 'true' || value === '1' || value.toLowerCase() === 'yes')
+                    return true;
+                return false;
+                break;
+            case 'enum':
+                if (!(value in schema.meta.enum.options)) {
+                    this.error(`Error: Value '${schema.name}=${value}' doesn't match any of the options: ${Object.keys(schema.meta.enum.options).join(', ')}`, 'syntax');
+                }
+                return value;
+                break;
+        }
+    }
+}
+class ScriptBuilder {
+    constructor(name) {
+        this.schema = {
+            args: []
+        };
+        this.schema.name = name;
+    }
+    d(description) {
+        this.schema.description = description;
+        return this;
+    }
+    arg(name, arg1, arg2) {
+        const def = arg2 || arg1;
+        const short = typeof arg1 === 'string' ? arg1 : undefined;
+        let schema;
+        if (name.startsWith('-')) {
+            const builder = new ScriptKeyArgBuilder(name, short);
+            def(builder);
+            schema = ScriptKeyArgBuilder.build(builder);
+        }
+        else {
+            const builder = new ScriptPosArgBuilder(name);
+            def(builder);
+            schema = ScriptPosArgBuilder.build(builder);
+        }
+        this.schema.args?.push(schema);
+        return this;
+    }
+    static build(builder) {
+        const args = builder.schema.args;
+        for (let i = 1; i < args.length; i++) {
+            if (args[i].type !== 'pos')
+                break;
+            const lastArg = args[i - 1];
+            if (lastArg.values[0].amount === '0+' || lastArg.values[0].amount === '1+') {
+                throw new Error('Only a single 0+/1+ positional argument is allowed, as the last one.');
+            }
+        }
+        builder.schema.args = [
+            ...args.filter(arg => arg.type === 'pos' && arg.values[0].amount === '1'),
+            ...args.filter(arg => arg.type === 'pos' && arg.values[0].amount !== '1'),
+            ...args.filter(arg => arg.type === 'key')
+        ];
+        return builder.schema;
+    }
+}
+class ScriptPosArgBuilder {
+    constructor(name) {
+        this.schema = {};
+        this.schema.name = name;
+        this.schema.type = 'pos';
+        this.schema.values = [{
+                name,
+                type: 'string',
+                amount: '1',
+                meta: {}
+            }];
+    }
+    d(description) {
+        this.schema.description = description;
+        return this;
+    }
+    value(def) {
+        const builder = new ScriptValueBuilder(this.schema.name);
+        def(builder);
+        const value = builder.build();
+        this.schema.values = [value];
+        return this;
+    }
+    static build(builder) {
+        return builder.schema;
+    }
+}
+class ScriptKeyArgBuilder {
+    constructor(name, short) {
+        this.schema = {};
+        this.schema.name = name;
+        this.schema.short = short;
+        this.schema.type = 'key';
+        this.schema.values = [];
+    }
+    d(description) {
+        this.schema.description = description;
+        return this;
+    }
+    value(name, def) {
+        const lastValue = this.schema.values.at(-1);
+        if (lastValue?.amount === '0+' || lastValue?.amount === '1+') {
+            throw new Error('Only a single 0+/1+ value is allowed, as the last one.');
+        }
+        const builder = new ScriptValueBuilder(name);
+        def(builder);
+        const value = builder.build();
+        this.schema.values.push(value);
+        return this;
+    }
+    static build(builder) {
+        builder.schema.values = [
+            ...builder.schema.values.filter(value => value.amount === '1'),
+            ...builder.schema.values.filter(value => value.amount !== '1'),
+        ];
+        return builder.schema;
+    }
+}
+class ScriptValueBuilder {
+    constructor(name) {
+        this.schema = {
+            name,
+            type: 'string',
+            amount: '1',
+            meta: {}
+        };
+    }
+    d(description) {
+        this.schema.description = description;
+        return this;
+    }
+    get optional() {
+        if (this.schema.amount === '1') {
+            this.schema.amount = '1?';
+        }
+        return this;
+    }
+    get zero_or_more() {
+        this.schema.amount = '0+';
+        return this;
+    }
+    get one_or_more() {
+        this.schema.amount = '1+';
+        return this;
+    }
+    get boolean() {
+        this.schema = {
+            ...this.schema,
+            type: 'boolean',
+            meta: {}
+        };
+        return this;
+    }
+    enum(options) {
+        const opts = {};
+        if (Array.isArray(options)) {
+            for (const opt of options) {
+                opts[opt] = { name: opt };
+            }
+        }
+        else {
+            for (const name in options) {
+                opts[name] = { name, description: options[name] };
+            }
+        }
+        this.schema = {
+            ...this.schema,
+            type: 'enum',
+            meta: {
+                enum: {
+                    options: opts
+                }
+            }
+        };
+        return this;
+    }
+    build() { return this.schema; }
+}

package/lib/engine/transaction/nodes/bucket_query.trx_node.js

@@ -72,7 +72,7 @@ class BucketQueryTrxNode {
     }
     async first() {
         const results = await this.wrap('queryFirst', { schema: this.query, view: this.view }, (trx, bucket) => {
-            return bucket.query(this.trx, this.query, {
+            return bucket.query(trx, this.query, {
                 perPage: 1
             }, this.view, {
                 no_tenancy: !this.enableTenancy,

package/lib/engine/util/dotenv.d.ts

@@ -1,9 +1,8 @@
 export type DotEnvFile = Record<string, string>;
 export declare class DotEnv {
-    static path: string;
-    static load(): void;
-    static parse(): DotEnvFile;
-    static save(dotenv: DotEnvFile): void;
-    static get(key: string): string;
-    static set(key: string, value: string): void;
+    static load(filename?: string): void;
+    static parse(filename?: string): DotEnvFile;
+    static save(dotenv: DotEnvFile, filename?: string): void;
+    static get(key: string, filename?: string): string;
+    static set(key: string, value: string, filename?: string): void;
 }