nesoi 3.0.0

package/lib/engine/util/log.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Log = void 0;
+exports.scopeTag = scopeTag;
+exports.anyScopeTag = anyScopeTag;
+const string_1 = require("./string");
+const datetime_1 = require("../data/datetime");
+const LogLevel = ['off', 'error', 'warn', 'info', 'debug', 'trace'];
+function scopeTag(scope, scope_id) {
+    const color = {
+        compiler: 'brown',
+        trx: 'purple',
+        daemon: 'lightcyan',
+        app: 'lightcyan',
+        module: 'lightcyan',
+        layer: 'lightgreen',
+        virtual: 'lightgreen',
+        constants: 'lightblue',
+        externals: 'lightblue',
+        message: 'lightblue',
+        bucket: 'lightblue',
+        job: 'lightblue',
+        resource: 'lightblue',
+        controller: 'lightblue',
+        machine: 'lightblue',
+        queue: 'lightblue',
+    }[scope] || 'lightgray';
+    return (0, string_1.colored)(`${scope}:${scope_id}`, color);
+}
+function anyScopeTag(scopeWithId) {
+    const [_, module, type, name] = scopeWithId.match(/(\w+::)?(\w+):?(.+)?/) || [];
+    return (module ? module : '') + scopeTag(type, name || '');
+}
+class Log {
+    static error(scope, scope_id, message, obj) {
+        if (LogLevel.indexOf(Log.level) < 1) {
+            return;
+        }
+        this.push('error', scope, scope_id, message, obj);
+    }
+    static warn(scope, scope_id, message, obj) {
+        if (LogLevel.indexOf(Log.level) < 2) {
+            return;
+        }
+        this.push('warn', scope, scope_id, message, obj);
+    }
+    static info(scope, scope_id, message, obj) {
+        if (LogLevel.indexOf(Log.level) < 3) {
+            return;
+        }
+        this.push('info', scope, scope_id, message, obj);
+    }
+    static debug(scope, scope_id, message, obj) {
+        if (LogLevel.indexOf(Log.level) < 4) {
+            return;
+        }
+        this.push('debug', scope, scope_id, message, obj);
+    }
+    static trace(scope, scope_id, message, obj) {
+        if (LogLevel.indexOf(Log.level) < 5) {
+            return;
+        }
+        this.push('trace', scope, scope_id, message, obj);
+    }
+    static push(level, scope, scope_id, message, obj) {
+        const time = (0, string_1.colored)(`${datetime_1.NesoiDatetime.shortNow()}`, 'darkgray');
+        const head = scopeTag(scope, scope_id);
+        if (level === 'error') {
+            console.log(`${time} ${this.l[level]} ${head}\t${(0, string_1.colored)(message, 'lightred')}`);
+            if (obj) {
+                let text = JSON.stringify(obj, undefined, 2);
+                text = text.replace(/\\n/g, '\n');
+                console.log((0, string_1.colored)(text, 'red'));
+            }
+        }
+        else {
+            console.log(`${time} ${this.l[level]} ${head}\t${message}`);
+            if (obj) {
+                console.debug(obj);
+            }
+        }
+    }
+}
+exports.Log = Log;
+Log.level = 'warn';
+Log.l = {
+    off: (0, string_1.colored)('', 'black'),
+    error: (0, string_1.colored)('ERROR', 'lightred'),
+    warn: (0, string_1.colored)('WARN', 'yellow'),
+    info: (0, string_1.colored)('INFO', 'lightblue'),
+    debug: (0, string_1.colored)('DEBUG', 'lightgreen'),
+    trace: (0, string_1.colored)('TRACE', 'lightpurple'),
+};

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

@@ -0,0 +1,63 @@
+import { NesoiDate } from '../data/date';
+import { $MessageTemplateFields } from '../../elements/entities/message/template/message_template.schema';
+import { $Module, BucketName, ViewName } from "../../schema";
+import { AnyTrxNode } from '../transaction/trx_node';
+import { Decimal } from '../data/decimal';
+import { NesoiDatetime } from '../data/datetime';
+export declare function parseBoolean(field: {
+    name: string;
+    alias: string;
+}, value: any, array: boolean): Promise<boolean | boolean[]>;
+export declare function parseDate(field: {
+    name: string;
+    alias: string;
+}, value: any, array: boolean): Promise<NesoiDate | NesoiDate[]>;
+export declare function parseDatetime(field: {
+    name: string;
+    alias: string;
+}, value: any, array: boolean): Promise<NesoiDatetime | NesoiDatetime[]>;
+export declare function parseDecimal(field: {
+    name: string;
+    alias: string;
+}, value: any, array: boolean): Promise<Decimal | Decimal[]>;
+export declare function parseEnum(raw: Record<string, any>, field: {
+    name: string;
+    alias: string;
+}, value: any, array: boolean, options: string | readonly string[] | Record<string, any>, trx: AnyTrxNode): Promise<any>;
+export declare function parseFile(field: {
+    name: string;
+    alias: string;
+}, value: any, array: boolean, options?: {
+    maxSize?: number;
+    extnames?: string[];
+}): Promise<any>;
+export declare function parseFloat_(field: {
+    name: string;
+    alias: string;
+}, value: any, array: boolean): Promise<number | number[]>;
+export declare function parseId<M extends $Module, Name extends BucketName<M>, View extends ViewName<M['buckets'][Name]> | undefined>(field: {
+    name: string;
+    alias: string;
+}, value: any, array: boolean, trx: AnyTrxNode, bucket: Name, view?: View): Promise<unknown>;
+export declare function parseInt_(field: {
+    name: string;
+    alias: string;
+}, value: any, array: boolean): Promise<number | number[]>;
+export declare function parseString(field: {
+    name: string;
+    alias: string;
+}, value: any, array: boolean): Promise<string | string[]>;
+export declare function parseStringOrNumber(field: {
+    name: string;
+    alias: string;
+}, value: any, array: boolean): Promise<string | number | (string | number)[]>;
+export declare function parseDict(field: {
+    name: string;
+    alias: string;
+    children?: $MessageTemplateFields;
+}, value: any, array: boolean, trx: AnyTrxNode, parseFields: (trx: AnyTrxNode, fields: $MessageTemplateFields, obj: Record<string, any>) => Promise<Record<string, any>>): Promise<unknown>;
+export declare function parseObj(field: {
+    name: string;
+    alias: string;
+    children?: $MessageTemplateFields;
+}, value: any, array: boolean, trx: AnyTrxNode, parseFields: (trx: AnyTrxNode, fields: $MessageTemplateFields, obj: Record<string, any>) => Promise<Record<string, any>>): Promise<unknown>;

package/lib/engine/util/parse.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBoolean = parseBoolean;
+exports.parseDate = parseDate;
+exports.parseDatetime = parseDatetime;
+exports.parseDecimal = parseDecimal;
+exports.parseEnum = parseEnum;
+exports.parseFile = parseFile;
+exports.parseFloat_ = parseFloat_;
+exports.parseId = parseId;
+exports.parseInt_ = parseInt_;
+exports.parseString = parseString;
+exports.parseStringOrNumber = parseStringOrNumber;
+exports.parseDict = parseDict;
+exports.parseObj = parseObj;
+const date_1 = require("../data/date");
+const error_1 = require("../data/error");
+const tree_1 = require("../data/tree");
+const decimal_1 = require("../data/decimal");
+const datetime_1 = require("../data/datetime");
+// TODO: check the performance of this wild thing below
+async function parse(type, field, value, array, fn) {
+    if (array) {
+        if (!Array.isArray(value)) {
+            throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value, type: `${type}[]` });
+        }
+        const parsed = [];
+        for (const v in value) {
+            parsed.push(await fn(value[v]));
+        }
+        return parsed;
+    }
+    return fn(value);
+}
+function parseBoolean(field, value, array) {
+    return parse('boolean', field, value, array, (v) => {
+        if (v === 'true' || v === 1) {
+            return true;
+        }
+        if (v === 'false' || v === 0) {
+            return false;
+        }
+        if (typeof v === 'boolean') {
+            return v;
+        }
+        throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value: v, type: 'boolean' });
+    });
+}
+function parseDate(field, value, array) {
+    return parse('date', field, value, array, (v) => {
+        // TODO: limit to date
+        if (typeof v === 'string') {
+            return date_1.NesoiDate.fromISO(v);
+        }
+        throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value: v, type: 'date' });
+    });
+}
+function parseDatetime(field, value, array) {
+    return parse('datetime', field, value, array, (v) => {
+        if (typeof v === 'string') {
+            return datetime_1.NesoiDatetime.fromISO(v);
+        }
+        throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value: v, type: 'datetime' });
+    });
+}
+function parseDecimal(field, value, array) {
+    return parse('decimal', field, value, array, (v) => {
+        if (typeof v === 'string') {
+            return new decimal_1.Decimal(v);
+        }
+        throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value: v, type: 'float' });
+    });
+}
+function parseEnum(raw, field, value, array, options, trx) {
+    return parse('enum', field, value, array, (v) => {
+        if (typeof v === 'string') {
+            if (typeof options === 'string') {
+                let enumName = options;
+                const enumPath = enumName.match(/(.*)\.\{(.*)\}$/);
+                let _enum;
+                if (enumPath) {
+                    enumName += enumPath[1] + '.' + enumPath[2];
+                    try {
+                        _enum = trx.enum(enumName);
+                    }
+                    catch {
+                        const v = tree_1.Tree.get(raw, enumPath[2]);
+                        throw error_1.NesoiError.Message.InvalidEnumScope(field, v, enumPath[2]);
+                    }
+                }
+                else {
+                    _enum = trx.enum(enumName);
+                }
+                const keys = _enum.keys();
+                if (keys.includes(v)) {
+                    return v;
+                }
+                else {
+                    throw error_1.NesoiError.Message.InvalidFieldEnumValue({ field: field.alias, value: v, type: 'enum', options: keys });
+                }
+            }
+            else if (Array.isArray(options)) {
+                if (options.includes(v)) {
+                    return v;
+                }
+                else {
+                    throw error_1.NesoiError.Message.InvalidFieldEnumValue({ field: field.alias, value: v, type: 'enum', options });
+                }
+            }
+            else if (typeof options === 'object') {
+                if (v in options) {
+                    return options[v];
+                }
+                else {
+                    throw error_1.NesoiError.Message.InvalidFieldEnumValue({ field: field.alias, value: v, type: 'enum', options: Object.keys(options) });
+                }
+            }
+        }
+        throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value: v, type: 'string' });
+    });
+}
+function parseFile(field, value, array, options) {
+    return parse('file', field, value, array, (v) => {
+        if (!v.size || !v.extname || !v.data || !v.data.clientName) {
+            throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value: v, type: 'file' });
+        }
+        if (options?.maxSize) {
+            if (v.size > options?.maxSize) {
+                throw error_1.NesoiError.Message.FileTooBig(field, options?.maxSize);
+            }
+        }
+        if (options?.extnames) {
+            if (!options?.extnames.includes(v.extname)) {
+                throw error_1.NesoiError.Message.FileExtNotAllowed(field, options?.extnames);
+            }
+        }
+        return v;
+    });
+}
+function parseFloat_(field, value, array) {
+    return parse('float', field, value, array, (v) => {
+        if (typeof v === 'string') {
+            const val = parseFloat(v);
+            if (!Number.isNaN(val)) {
+                return val;
+            }
+        }
+        else if (typeof v === 'number') {
+            if (!Number.isNaN(v)) {
+                return v;
+            }
+        }
+        throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value: v, type: 'float' });
+    });
+}
+async function parseId(field, value, array, trx, bucket, view) {
+    return parse('id', field, value, array, (async (v) => {
+        // TODO: validate by field type
+        const val = v;
+        if (typeof v !== 'string' && typeof v !== 'number') {
+            throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value: v, type: 'id' });
+        }
+        return {
+            id: val,
+            obj: view
+                ? await trx.bucket(bucket).viewOneOrFail(val, view)
+                : await trx.bucket(bucket).readOneOrFail(val)
+        };
+    })); // type only required on query parsers
+}
+function parseInt_(field, value, array) {
+    return parse('int', field, value, array, (v) => {
+        if (typeof v === 'string') {
+            const val = parseInt(v);
+            if (!Number.isNaN(val)) {
+                return val;
+            }
+        }
+        else if (typeof v === 'number') {
+            const val = Math.floor(v);
+            if (!Number.isNaN(val)) {
+                return val;
+            }
+        }
+        throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value: v, type: 'integer' });
+    });
+}
+function parseString(field, value, array) {
+    return parse('string', field, value, array, (v) => {
+        if (typeof v === 'string') {
+            return v;
+        }
+        throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value: v, type: 'string' });
+    });
+}
+function parseStringOrNumber(field, value, array) {
+    return parse('string_or_number', field, value, array, (v) => {
+        if (typeof v === 'string' || typeof v === 'number') {
+            return v;
+        }
+        throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value: v, type: 'string_or_number' });
+    });
+}
+async function parseDict(field, value, array, trx, parseFields) {
+    return parse('dict', field, value, array, (async (v) => {
+        if (typeof v === 'object') {
+            const parsed = {};
+            if (field.children) {
+                for (const k in v) {
+                    const pv = await parseFields(trx, field.children, { __dict: v[k] });
+                    parsed[k] = pv['__dict'];
+                }
+            }
+            return parsed;
+        }
+        throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value: v, type: 'dict' });
+    }));
+}
+async function parseObj(field, value, array, trx, parseFields) {
+    return parse('obj', field, value, array, (async (v) => {
+        if (typeof v === 'object') {
+            if (field.children) {
+                return await parseFields(trx, field.children, v);
+            }
+            return v;
+        }
+        throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value: v, type: 'object' });
+    }));
+}

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

@@ -0,0 +1,3 @@
+export default class _Promise {
+    static solve<T>(result: T | Promise<T>): Promise<T>;
+}

package/lib/engine/util/promise.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// TODO: this probably isn't necessary, given that await on non-promises should work
+class _Promise {
+    static async solve(result) {
+        if (typeof result === 'object'
+            && 'then' in result
+            && typeof result.then === 'function') {
+            return result;
+        }
+        return new Promise(resolve => { resolve(result); });
+    }
+}
+exports.default = _Promise;

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

@@ -0,0 +1,6 @@
+export default class Shell {
+    /**
+     * Execute command in shell.
+     */
+    static cmd(cwd: string, cmd: string, stdin?: string[], stdout?: boolean, stderr?: boolean): Promise<unknown>;
+}

package/lib/engine/util/shell.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+class Shell {
+    /**
+     * Execute command in shell.
+     */
+    static cmd(cwd, cmd, stdin, stdout = true, stderr = true) {
+        console.log(cwd + '$ ' + cmd);
+        return new Promise(resolve => {
+            const cmds = cmd.split(' ');
+            const child = (0, child_process_1.spawn)(cmds[0], cmds.slice(1), { shell: true, stdio: [stdin ? null : process.stdin, stdout ? null : process.stdout, process.error], cwd });
+            if (stdin)
+                stdin.map(input => child.stdin.write(input + '\n'));
+            const out = {
+                stdout: [],
+                stderr: []
+            };
+            child.stdout.on('data', msg => {
+                if (stdout) {
+                    process.stdout.write(msg.toString());
+                }
+                out.stdout.push(msg.toString());
+            });
+            child.stderr.on('data', msg => {
+                if (stderr) {
+                    process.stderr.write(msg.toString());
+                }
+                out.stderr.push(msg.toString());
+            });
+            child.on('error', msg => {
+                console.error(msg);
+                throw 'Something went wrong when running the shell command. Read the logs.';
+            });
+            child.on('close', code => {
+                if (code !== 0) {
+                    throw `Shell command returned ${code} != 0. Read the logs.`;
+                }
+                resolve(out);
+            });
+        });
+    }
+}
+exports.default = Shell;

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

@@ -0,0 +1,18 @@
+export declare enum Color {
+    black = "0;30",
+    red = "0;31",
+    green = "0;32",
+    brown = "0;33",
+    blue = "0;34",
+    purple = "0;35",
+    cyan = "0;36",
+    lightgray = "0;37",
+    darkgray = "1;30",
+    lightred = "1;31",
+    lightgreen = "1;32",
+    yellow = "1;33",
+    lightblue = "1;34",
+    lightpurple = "1;35",
+    lightcyan = "1;36"
+}
+export declare function colored(msg: string, color: keyof typeof Color): string;

package/lib/engine/util/string.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Color = void 0;
+exports.colored = colored;
+var Color;
+(function (Color) {
+    Color["black"] = "0;30";
+    Color["red"] = "0;31";
+    Color["green"] = "0;32";
+    Color["brown"] = "0;33";
+    Color["blue"] = "0;34";
+    Color["purple"] = "0;35";
+    Color["cyan"] = "0;36";
+    Color["lightgray"] = "0;37";
+    Color["darkgray"] = "1;30";
+    Color["lightred"] = "1;31";
+    Color["lightgreen"] = "1;32";
+    Color["yellow"] = "1;33";
+    Color["lightblue"] = "1;34";
+    Color["lightpurple"] = "1;35";
+    Color["lightcyan"] = "1;36";
+})(Color || (exports.Color = Color = {}));
+function colored(msg, color) {
+    return '\x1b[' + Color[color] + 'm' + msg + '\x1b[0m';
+}

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

@@ -0,0 +1,7 @@
+export type Overlay<To, From> = Omit<To, keyof From> & From;
+export type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type MergeUnion<T> = {
+    [K in T extends T ? keyof T : never]: T extends {
+        [J in K]: any;
+    } ? T[K] : never;
+};

package/lib/engine/util/type.js

@@ -0,0 +1,3 @@
+"use strict";
+// Type used to replace properties on a type
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/schema.d.ts

@@ -0,0 +1,63 @@
+import { $Controller } from './elements/edge/controller/controller.schema';
+import { AnyUsers, User } from './engine/auth/authn';
+import { $Machine } from './elements/blocks/machine/machine.schema';
+import { $Constants } from './elements/entities/constants/constants.schema';
+import { $Message } from './elements/entities/message/message.schema';
+import { $Bucket } from './elements/entities/bucket/bucket.schema';
+import { $Job } from './elements/blocks/job/job.schema';
+import { $Resource } from './elements/blocks/resource/resource.schema';
+import { $Queue } from './elements/blocks/queue/queue.schema';
+import { $Externals } from './elements/blocks/externals/externals.schema';
+export type BuilderType = 'constants' | 'externals' | 'message' | 'bucket' | 'job' | 'resource' | 'machine' | 'controller' | 'queue';
+export type $Space = {
+    authnUsers: {
+        [x: string]: User;
+    };
+    modules: {
+        [x: string]: $Module;
+    };
+};
+export type $Module = {
+    name: string;
+    constants: $Constants;
+    externals: $Externals;
+    messages: {
+        [x: string]: $Message;
+    };
+    buckets: {
+        [x: string]: $Bucket;
+    };
+    jobs: {
+        [x: string]: $Job;
+    };
+    resources: {
+        [x: string]: $Resource;
+    };
+    machines: {
+        [x: string]: $Machine;
+    };
+    controllers: {
+        [x: string]: $Controller;
+    };
+    queues: {
+        [x: string]: $Queue;
+    };
+    '#input': $Message;
+    '#authn': AnyUsers;
+    '#providers': Record<string, any>;
+};
+export type ModuleName<$ extends $Space> = keyof $['modules'];
+export type MessageName<$ extends $Module> = keyof $['messages'];
+export type ScopedMessageNameWithId<$ extends $Module, Scope extends string, Id, Msgs extends Record<string, $Message> = $['messages']> = string & {
+    [Msg in keyof Msgs]: Msgs[Msg]['#parsed'] extends {
+        id: Id;
+    } ? Msg extends `${Scope}.${infer X}` ? (Msg | `@.${X}`) : Msg : never;
+}[keyof Msgs];
+export type ScopedMessageName<$ extends $Module, Scope extends string, Msgs extends string | symbol | number = keyof $['messages']> = string & {
+    [Msg in Msgs]: Msg extends Scope ? '@' | Msg : Msg extends `${Scope}.${infer X}` ? (Msg | `@.${X}`) : Msg;
+}[Msgs];
+export type ScopedMessage<$ extends $Module, Scope extends string, MsgName extends string> = MsgName extends '@' ? $['messages'][Scope] : MsgName extends `@.${infer X}` ? $['messages'][`${Scope}.${X}`] : $['messages'][MsgName];
+export type RawMessageInput<$ extends $Module, K extends MessageName<$>> = $['messages'][K]['#raw'];
+export type ViewName<$ extends $Bucket> = keyof $['views'];
+export type ViewObj<$ extends $Bucket, V extends ViewName<$>> = $['views'][V]['#data'];
+export type BucketName<$ extends $Module> = keyof $['buckets'];

package/lib/schema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,22 @@
+{
+    "name": "nesoi",
+    "version": "3.0.0",
+    "description": "Declarative framework for data-driven applications",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/nesoi-org/nesoi.git"
+    },
+    "keywords": [
+        "nesoi",
+        "postgresql"
+    ],
+    "author": "Hugo Aboud",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/nesoi-org/nesoi/issues"
+    },
+    "homepage": "https://github.com/nesoi-org/nesoi#readme",
+    "peerDependencies": {
+        "@types/node": "20.12.12"
+    }
+}

package/tools/compile.d.ts

@@ -0,0 +1 @@
+export {};