nesoi 3.0.0

package/lib/engine/cli/ui.js

@@ -0,0 +1,188 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const readline = __importStar(require("readline"));
+const stream_1 = require("stream");
+const string_1 = require("../util/string");
+class UI {
+    /**
+     * Show a list of options and let the user pick with up/down + enter
+     */
+    static async select(title, options, defaul = 0) {
+        return new Promise(resolve => {
+            UI.step(title);
+            let mute = true;
+            const mutableStdout = new stream_1.Writable({
+                write: function (chunk, encoding, callback) {
+                    if (!mute) {
+                        process.stdout.write(chunk, encoding);
+                    }
+                    callback();
+                }
+            });
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: mutableStdout,
+                terminal: true
+            });
+            let selected = defaul;
+            const print = () => {
+                mute = false;
+                for (let i = 0; i < options.length; i++) {
+                    rl.write((0, string_1.colored)(`${i === selected ? '» ' : '  '}` + options[i] + '\n', i === selected ? 'lightgreen' : 'lightgray'));
+                }
+                mute = true;
+            };
+            const clear = () => {
+                process.stdout.moveCursor(0, -options.length);
+            };
+            const onKeypress = function (ch, key) {
+                if (!key) {
+                    return;
+                }
+                if (key.name === 'up') {
+                    if (selected > 0) {
+                        selected -= 1;
+                    }
+                }
+                else if (key.name === 'down') {
+                    if (selected < options.length - 1) {
+                        selected += 1;
+                    }
+                }
+                else if (key.name === 'return') {
+                    rl.close();
+                    process.stdin.off('keypress', onKeypress);
+                    resolve(options[selected]);
+                }
+                clear();
+                print();
+            };
+            process.stdin.on('keypress', onKeypress);
+            print();
+        });
+    }
+    /**
+     * Ask a question and wait for the answer
+     */
+    static async question(text, defaul = '', prefix = '') {
+        return new Promise(resolve => {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout
+            });
+            rl.question((0, string_1.colored)(text + ' ', 'cyan') + prefix, val => {
+                rl.close();
+                resolve(val);
+            });
+            rl.write(defaul);
+        });
+    }
+    /**
+     * Show a message and wait for the user to press any key
+     */
+    static waitForAnyKey(title = 'Press any key to continue...') {
+        return new Promise(resolve => {
+            UI.step(title);
+            const mutableStdout = new stream_1.Writable({
+                write: function (chunk, encoding, callback) {
+                }
+            });
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: mutableStdout,
+                terminal: true
+            });
+            const onKeypress = function (ch, key) {
+                rl.close();
+                process.stdin.off('keypress', onKeypress);
+                resolve();
+            };
+            process.stdin.on('keypress', onKeypress);
+        });
+    }
+    /**
+     * 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')
+            return true;
+        return false;
+    }
+    // Print
+    static list(items) {
+        items.forEach(item => {
+            console.log((0, string_1.colored)('▫ ', 'lightgreen') + item);
+        });
+    }
+    static result(outcome, message, details) {
+        if (outcome === 'ok') {
+            console.log((0, string_1.colored)('✔ ' + message, 'lightgreen'));
+        }
+        else if (outcome === 'error') {
+            console.log((0, string_1.colored)('✕ ' + message, 'red'));
+            if (details) {
+                console.log('\t' + (0, string_1.colored)(details, 'lightred'));
+            }
+        }
+    }
+    /**
+     * Print a step message to the terminal
+     */
+    static step(msg) {
+        console.log((0, string_1.colored)('- ' + msg, 'green'));
+    }
+    /**
+     * Print a info message to the terminal
+     */
+    static info(msg) {
+        console.log((0, string_1.colored)(msg, 'lightblue'));
+    }
+    /**
+     * Print a command to the terminal
+     */
+    static cmd(msg) {
+        console.log((0, string_1.colored)('\n\t> ' + msg + '\n', 'darkgray'));
+    }
+    /**
+     * Print a error message to the terminal
+     */
+    static error(msg) {
+        console.log((0, string_1.colored)('! ' + msg, 'red'));
+    }
+}
+exports.default = UI;

package/lib/engine/daemon.d.ts

@@ -0,0 +1,35 @@
+import { $Module, $Space } from "../elements";
+import { ModuleName } from "../schema";
+import { AnyTrxEngine } from './transaction/trx_engine';
+import { AnyAppConfig } from './apps/app.config';
+import { AnyUsers, AuthnRequest } from './auth/authn';
+import { TrxNode } from './transaction/trx_node';
+import { TrxStatus } from './transaction/trx';
+import { AnyModule } from './module';
+export declare abstract class Daemon<S extends $Space, Modules extends ModuleName<S>> {
+    protected name: string;
+    protected trxEngines: Record<Modules, AnyTrxEngine>;
+    protected providers: Record<string, any>;
+    protected app?: AnyAppConfig | undefined;
+    private _cli?;
+    constructor(name: string, trxEngines: Record<Modules, AnyTrxEngine>, providers: Record<string, any>, app?: AnyAppConfig | undefined);
+    trx<K extends Modules & keyof S['modules']>(moduleName: K): DaemonTrx<S, S["modules"][K], {}>;
+    cli(): Promise<void>;
+    private bindControllers;
+    static reload(daemon: AnyDaemon, trxEngines: Record<string, AnyTrxEngine>, providers: Record<string, any>): void;
+    static get<T extends {
+        name: string;
+        providers: Record<string, any>;
+        app: AnyAppConfig;
+    }, K extends keyof T>(daemon: AnyDaemon | undefined, key: K): T[K];
+    static getModule<Modules extends ModuleName<any>, D extends Daemon<any, Modules>>(daemon: D, module: Modules): import("./module").Module<any, any>;
+    static getModules(daemon: AnyDaemon): AnyModule[];
+}
+export declare class DaemonTrx<S extends $Space, M extends $Module, Authn extends AnyUsers = {}> {
+    private trxEngine;
+    private _authn?;
+    constructor(trxEngine: AnyTrxEngine);
+    authn<Authn extends AuthnRequest<keyof S['authnUsers']>>(authn: Authn): DaemonTrx<S, M, { [K in keyof Authn]: S["authnUsers"][K & keyof S["authnUsers"]]; }>;
+    run<Output>(fn: (trx: TrxNode<S, M, Authn>) => Promise<Output>): Promise<TrxStatus<Output>>;
+}
+export type AnyDaemon = Daemon<any, any>;

package/lib/engine/daemon.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaemonTrx = exports.Daemon = void 0;
+const log_1 = require("./util/log");
+const error_1 = require("./data/error");
+const cli_1 = require("./cli/cli");
+class Daemon {
+    constructor(name, trxEngines, providers, app) {
+        this.name = name;
+        this.trxEngines = trxEngines;
+        this.providers = providers;
+        this.app = app;
+        this.bindControllers();
+        log_1.Log.info('daemon', name, 'Woo-ha!');
+    }
+    trx(moduleName) {
+        const trxEngine = this.trxEngines[moduleName];
+        if (!trxEngine) {
+            throw error_1.NesoiError.Trx.ModuleNotFound(moduleName);
+        }
+        return new DaemonTrx(trxEngine);
+    }
+    async cli() {
+        this._cli = new cli_1.CLI(this, this.app?.cli);
+        await this._cli.run();
+    }
+    bindControllers() {
+        log_1.Log.info('daemon', this.name, 'Binding controllers');
+        for (const t in this.trxEngines) {
+            const module = this.trxEngines[t].getModule();
+            for (const c in module.controllers) {
+                const controller = module.controllers[c];
+                controller.bind(this);
+            }
+        }
+    }
+    static reload(daemon, trxEngines, providers) {
+        log_1.Log.info('daemon', this.name, 'Reloaded');
+        daemon.trxEngines = trxEngines;
+        daemon.providers = providers;
+    }
+    static get(daemon, key) {
+        return daemon?.[key];
+    }
+    static getModule(daemon, module) {
+        return daemon.trxEngines[module].getModule();
+    }
+    static getModules(daemon) {
+        return Object.values(daemon.trxEngines)
+            .map((trx) => trx.getModule());
+    }
+}
+exports.Daemon = Daemon;
+class DaemonTrx {
+    constructor(trxEngine) {
+        this.trxEngine = trxEngine;
+    }
+    authn(authn) {
+        this._authn = authn;
+        return this;
+    }
+    async run(fn) {
+        return this.trxEngine.trx(fn, this._authn);
+    }
+}
+exports.DaemonTrx = DaemonTrx;

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

@@ -0,0 +1,10 @@
+export declare class NesoiDate {
+    day: number;
+    month: number;
+    year: number;
+    constructor(day: number, month: number, year: number);
+    static fromISO(iso: string): NesoiDate;
+    static now(): NesoiDate;
+    static isoNow(): string;
+    toISO(): string;
+}

package/lib/engine/data/date.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NesoiDate = void 0;
+const error_1 = require("./error");
+class NesoiDate {
+    constructor(day, month, year) {
+        this.day = day;
+        this.month = month;
+        this.year = year;
+    }
+    static fromISO(iso) {
+        // TODO: Check invalid ISO
+        const match = iso.match(/(\d{4})-([01]\d)-([0-3]\d)/);
+        if (!match) {
+            throw error_1.NesoiError.Data.InvalidISOString({ value: iso });
+        }
+        const jsDate = new Date(iso);
+        return new NesoiDate(parseInt(match[3]), parseInt(match[2]), parseInt(match[1]));
+    }
+    static now() {
+        const iso = new Date().toISOString().split('T')[0];
+        return NesoiDate.fromISO(iso);
+    }
+    static isoNow() {
+        const iso = new Date().toISOString().split('T')[0];
+        return iso;
+    }
+    toISO() {
+        return `${('0000' + this.year).slice(-4)}-${('00' + this.month).slice(-2)}-${('00' + this.day).slice(-2)}`;
+    }
+}
+exports.NesoiDate = NesoiDate;

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

@@ -0,0 +1,12 @@
+export declare class NesoiDatetime {
+    /**
+     * Time in milliseconds since 1970-01-01
+     */
+    epoch: number;
+    constructor(jsDate?: Date);
+    static fromISO(iso: string): NesoiDatetime;
+    static now(): NesoiDatetime;
+    static isoNow(): string;
+    static shortNow(): string;
+    toISO(): string;
+}

package/lib/engine/data/datetime.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NesoiDatetime = void 0;
+const error_1 = require("./error");
+class NesoiDatetime {
+    constructor(jsDate) {
+        this.epoch = (jsDate || new Date()).getTime();
+    }
+    static fromISO(iso) {
+        // TODO: Check invalid ISO
+        const match = iso.match(/(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))/);
+        if (!match) {
+            throw error_1.NesoiError.Data.InvalidISOString({ value: iso });
+        }
+        const jsDate = new Date(iso);
+        return new NesoiDatetime(jsDate);
+    }
+    static now() {
+        return new NesoiDatetime();
+    }
+    static isoNow() {
+        return new Date().toISOString();
+    }
+    static shortNow() {
+        return new Date().toISOString().slice(5, 19);
+    }
+    toISO() {
+        return new Date(this.epoch).toISOString();
+    }
+}
+exports.NesoiDatetime = NesoiDatetime;

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

@@ -0,0 +1,11 @@
+export declare class Decimal {
+    private neg;
+    private left;
+    private right;
+    private prec;
+    private r_pad;
+    private r_exp;
+    constructor(value: string, pLeft?: number, pRight?: number);
+    toString(): string;
+    toFloat(): number;
+}

package/lib/engine/data/decimal.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Decimal = void 0;
+const error_1 = require("./error");
+class Decimal {
+    constructor(value, pLeft = 12, pRight = 12) {
+        this.neg = false;
+        let payload = value.trim();
+        if (value[0] === '-') {
+            this.neg = true;
+            payload = value.slice(1);
+        }
+        this.prec = {
+            left: pLeft,
+            right: pRight
+        };
+        if (typeof pLeft !== 'number' || Number.isNaN(pLeft) || !Number.isFinite(pLeft) ||
+            typeof pRight !== 'number' || Number.isNaN(pRight) || !Number.isFinite(pRight) ||
+            pLeft < 1 || pLeft > 12 ||
+            pRight < 1 || pRight > 12) {
+            throw error_1.NesoiError.Data.UnsupportedDecimalPrecision({ left: pLeft, right: pRight });
+        }
+        // Possibly an integer value
+        if (!payload.includes('.')) {
+            // If it contains non-digits, it's invalid
+            if (payload.match(/\D/)) {
+                throw error_1.NesoiError.Data.InvalidDecimalValue({ value });
+            }
+            this.left = parseInt(payload);
+            this.right = 0;
+            this.r_pad = 0;
+            this.r_exp = 0;
+        }
+        // Possibly a real value
+        else {
+            const [_, l, r] = payload.match(/^(\d*)\.(\d*)$/) || [undefined, null, null];
+            // If any side contains non-digits, it's invalid
+            if (l == null || r == null) {
+                throw error_1.NesoiError.Data.InvalidDecimalValue({ value });
+            }
+            // Remove leading/trailing zeros
+            const lval = l.replace(/^0+/, '') || '0';
+            const rval = r.replace(/0+$/, '') || '0';
+            if (lval.length > this.prec.left) {
+                throw error_1.NesoiError.Data.DecimalLeftTooBig({ value, prec: this.prec.left });
+            }
+            if (rval.length > this.prec.right) {
+                throw error_1.NesoiError.Data.DecimalRightTooBig({ value, prec: this.prec.right });
+            }
+            this.left = parseInt(lval);
+            this.right = parseInt(rval);
+            this.r_pad = rval.match(/^0+/)?.[0].length || 0;
+            this.r_exp = 10 ** (-rval.length);
+        }
+        if (isNaN(this.left) || isNaN(this.right)) {
+            throw error_1.NesoiError.Data.InvalidDecimalValue({ value });
+        }
+    }
+    toString() {
+        const neg = this.neg ? '-' : '';
+        const pad0 = Array(this.r_pad).fill('0').join('');
+        const right = pad0 + this.right;
+        const pad1 = Array(this.prec.right - right.length).fill('0').join('');
+        return neg + this.left + '.' + right + pad1;
+    }
+    toFloat() {
+        return (this.neg ? -1 : 1) * (this.left + this.right * this.r_exp);
+    }
+}
+exports.Decimal = Decimal;

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

@@ -0,0 +1,213 @@
+import { AnyModule } from "../module";
+import { $MessageTemplateRule } from "../../elements/entities/message/template/message_template.schema";
+import { $Resource } from "../../elements/blocks/resource/resource.schema";
+import { $Controller } from "../../elements/edge/controller/controller.schema";
+import { AnyQuery } from "../../elements/entities/bucket/query/nql.schema";
+export declare namespace NesoiError {
+    class BaseError extends Error {
+        name: string;
+        status: number;
+        data?: Record<string, any> | undefined;
+        constructor(name: string, message: string, status?: number, data?: Record<string, any> | undefined);
+        toString(): string;
+    }
+    namespace Builder {
+        namespace Job {
+            function NoMethod($: {
+                job: string;
+            }): BaseError;
+        }
+        namespace Bucket {
+            function UnknownModelField(path: string): BaseError;
+            function UnknownGraphLink(name: string): BaseError;
+            function UnknownViewName(name: string): BaseError;
+            function NoChildrenOnViewGroup(name: string): BaseError;
+            function CompositionWithPivotNotAllowed(): BaseError;
+        }
+        namespace Message {
+            function UnknownTemplateFieldType(type: string): BaseError;
+            function UnknownModuleMessage(name: string): BaseError;
+        }
+        namespace Resource {
+            function BucketNotFound(resource: string, bucket: string): BaseError;
+            function CustomInputRequiresPrepare(resource: string): BaseError;
+        }
+    }
+    namespace App {
+        function ModuleNotFound(module: string): BaseError;
+    }
+    namespace Module {
+        function UnknownBuilderType(module: AnyModule, filename: string, key: string, $b: string): BaseError;
+        function EnumNotFound(module: AnyModule, name: string): BaseError;
+        function JobNotIncluded(module: AnyModule, job: string): BaseError;
+        function ResourceNotIncluded(module: AnyModule, resource: string): BaseError;
+        function MachineNotIncluded(module: AnyModule, machine: string): BaseError;
+        function QueueNotIncluded(module: AnyModule, queue: string): BaseError;
+        function ControllerNotIncluded(module: AnyModule, controller: string): BaseError;
+        function InlineMessageNotFoundOnMerge(msg: string): BaseError;
+        function InlineJobNotFoundOnMerge(job: string): BaseError;
+    }
+    namespace Authn {
+        function NoProvidersRegisteredForModule(module: string): BaseError;
+        function NoProviderRegisteredForModule(module: string, provider: string): BaseError;
+        function NoUsersAuthenticatedForTrxNode(globalId: string): BaseError;
+    }
+    namespace Trx {
+        function ModuleNotFound(module: string): BaseError;
+        function NodeNotFound(node: string, trx: string): BaseError;
+    }
+    namespace Bucket {
+        function InvalidId($: {
+            bucket: string;
+            id: any;
+        }): BaseError;
+        function ObjNotFound($: {
+            bucket: string;
+            id: number | string;
+        }): BaseError;
+        function ViewNotFound($: {
+            bucket: string;
+            view: string;
+        }): BaseError;
+        function NoUpdatedAtField($: {
+            bucket: string;
+            id: number | string;
+            field: string;
+        }): BaseError;
+        function MissingComposition($: {
+            method: string;
+            bucket: string;
+            link: string;
+        }): BaseError;
+        function CompositionValueShouldBeArray($: {
+            method: string;
+            bucket: string;
+            link: string;
+        }): BaseError;
+        namespace Graph {
+            function LinkNotFound($: {
+                bucket: string;
+                link: string;
+            }): BaseError;
+            function LinkManyRefOnSelfWithoutArrayValue(link: string): BaseError;
+            function LinkManyRefOffSelfWithArrayValue(link: string): BaseError;
+            function LinkOneWithArrayValue(link: string): BaseError;
+            function PivotValueIsUndefined(link: string): BaseError;
+            function RequiredLinkNotFound(link: string, value: any): BaseError;
+        }
+        namespace Query {
+            function NoResults($: {
+                bucket: string;
+                query: AnyQuery<any, any>;
+            }): BaseError;
+            function ViewNotFound(bucket: string, view: string): BaseError;
+            function PathNotFoundOnView(path: string, view: string): BaseError;
+            function NonModelSearchNotImplemented(path: string, view: string): BaseError;
+            function InvalidRuleValueType(path: string, type: string): BaseError;
+            function InvalidOpForFieldType(path: string, op: string, type: string): BaseError;
+        }
+        namespace Fieldpath {
+            function InvalidIndexLength($: {
+                fieldpath: string;
+                index: (string | number)[];
+            }): BaseError;
+        }
+    }
+    namespace Data {
+        function InvalidISOString($: {
+            value: string;
+        }): BaseError;
+        function UnsupportedDecimalPrecision($: {
+            left: number;
+            right: number;
+        }): BaseError;
+        function DecimalLeftTooBig($: {
+            value: string;
+            prec: number;
+        }): BaseError;
+        function DecimalRightTooBig($: {
+            value: string;
+            prec: number;
+        }): BaseError;
+        function InvalidDecimalValue($: {
+            value: string;
+        }): BaseError;
+    }
+    namespace Message {
+        function NoType($: {
+            raw: Record<string, any>;
+        }): BaseError;
+        function InvalidType($: {
+            type: any;
+        }): BaseError;
+        function NotSupportedByModule($: {
+            type: string;
+            module: string;
+        }): BaseError;
+        function InvalidEnumScope(prop: {
+            name: string;
+            alias?: string;
+        }, value: any, fieldpath: string): BaseError;
+        function InvalidFieldEnumValue($: {
+            field: string;
+            value: any;
+            type: string;
+            options: string[];
+        }): BaseError;
+        function InvalidFieldType($: {
+            field: string;
+            value: any;
+            type: string;
+        }): BaseError;
+        function UnsanitaryValue($: {
+            details: string;
+        }): BaseError;
+        function FieldIsRequired($: {
+            field: string;
+            path: string;
+            value: any;
+        }): BaseError;
+        function RuleFailed(rule: $MessageTemplateRule<any, any>, error: string): BaseError;
+        function FileTooBig(prop: {
+            name: string;
+            alias?: string;
+        }, maxSize: number): BaseError;
+        function FileExtNotAllowed(prop: {
+            name: string;
+            alias?: string;
+        }, options: string[]): BaseError;
+    }
+    namespace Block {
+        function InvalidSchema($: {
+            name: string;
+            type: string;
+            expectedType: string;
+        }): BaseError;
+        function MessageNotSupported($: {
+            block: string;
+            message: string;
+        }): BaseError;
+    }
+    namespace Job {
+        function ConditionUnmet($: {
+            job: string;
+            error: string;
+        }): BaseError;
+    }
+    namespace Resource {
+        function ViewNotSupported(resource: $Resource): BaseError;
+        function QueryNotSupported(resource: $Resource): BaseError;
+        function CreateNotSupported(resource: $Resource): BaseError;
+        function UpdateNotSupported(resource: $Resource): BaseError;
+        function DeleteNotSupported(resource: $Resource): BaseError;
+    }
+    namespace Machine {
+        function MessageHasNoId(alias: string): BaseError;
+        function ObjNotFound(alias: string, id: number | string): BaseError;
+        function StateNotFound(alias: string, id: number | string): BaseError;
+        function UnmetCondition(alias: string, msg: string): BaseError;
+    }
+    namespace Controller {
+        function PortNotFound(controller: $Controller, port: string): BaseError;
+    }
+}