nesoi 3.3.7 → 3.3.8

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

package/lib/engine/util/dotenv.js

@@ -37,16 +37,18 @@ exports.DotEnv = void 0;
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 class DotEnv {
-    static load() {
-        if (!fs.existsSync(this.path))
+    static load(filename = '.env') {
+        const filepath = path.join(process.cwd(), filename);
+        if (!fs.existsSync(filepath))
             return;
-        const file = this.parse();
+        const file = this.parse(filename);
         for (const key in file) {
             process.env[key] = file[key];
         }
     }
-    static parse() {
-        const file = fs.readFileSync(this.path, 'utf-8');
+    static parse(filename = '.env') {
+        const filepath = path.join(process.cwd(), filename);
+        const file = fs.readFileSync(filepath, 'utf-8');
         return file.split('\n').reduce((a, line) => {
             const p = line.split('=');
             if (p.length > 1)
@@ -54,19 +56,19 @@ class DotEnv {
             return a;
         }, {});
     }
-    static save(dotenv) {
+    static save(dotenv, filename = '.env') {
+        const filepath = path.join(process.cwd(), filename);
         const file = Object.keys(dotenv).map(p => p + '=' + dotenv[p]).join('\n');
-        fs.writeFileSync(this.path, file);
+        fs.writeFileSync(filepath, file);
     }
-    static get(key) {
-        const dotenv = this.parse();
+    static get(key, filename = '.env') {
+        const dotenv = this.parse(filename);
         return dotenv[key];
     }
-    static set(key, value) {
-        const dotenv = this.parse();
+    static set(key, value, filename = '.env') {
+        const dotenv = this.parse(filename);
         dotenv[key] = value;
         this.save(dotenv);
     }
 }
 exports.DotEnv = DotEnv;
-DotEnv.path = path.join(process.cwd(), '.env');

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "nesoi",
-    "version": "3.3.7",
+    "version": "3.3.8",
     "description": "Declarative framework for data-driven applications",
     "repository": {
         "type": "git",