nesoi 3.0.0

package/lib/elements/entities/constants/constants.schema.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$Constants = exports.$ConstantEnum = exports.$ConstantEnumOption = exports.$ConstantValue = void 0;
+class $ConstantValue {
+    constructor(scope, key, value) {
+        this.scope = scope;
+        this.key = key;
+        this.value = value;
+    }
+}
+exports.$ConstantValue = $ConstantValue;
+class $ConstantEnumOption {
+    constructor(key, value) {
+        this.key = key;
+        this.value = value;
+    }
+}
+exports.$ConstantEnumOption = $ConstantEnumOption;
+class $ConstantEnum {
+    constructor(name, options) {
+        this.name = name;
+        this.options = options;
+    }
+    static keys(schema) {
+        return Object.keys(schema.options);
+    }
+    static get(schema, key) {
+        return schema.options[key].value;
+    }
+}
+exports.$ConstantEnum = $ConstantEnum;
+class $Constants {
+    constructor(name, values = {}, enums = {}) {
+        this.name = name;
+        this.values = values;
+        this.enums = enums;
+        this.$t = 'constants';
+        this.module = this.name;
+    }
+    static merge(to, from) {
+        Object.assign(to.values, from.values);
+        Object.assign(to.enums, from.enums);
+    }
+}
+exports.$Constants = $Constants;

package/lib/elements/entities/message/message.builder.d.ts

@@ -0,0 +1,33 @@
+import { $Module, $Space } from "../../../schema";
+import { $Message } from './message.schema';
+import { MessageTemplateDef } from './template/message_template.builder';
+import { $MessageInfer } from './message.infer';
+import { ModuleTree } from "../../../engine/tree";
+import { ResolvedBuilderNode } from "../../../engine/dependency";
+export declare class MessageBuilder<Space extends $Space, Module extends $Module, Message extends $Message = $Message> {
+    private module;
+    private name;
+    $b: "message";
+    private alias?;
+    private _template;
+    constructor(module: string, name: string);
+    as(alias: string): this;
+    template<Def extends MessageTemplateDef<Space, Module, Message['name']>>($: Def): MessageBuilder<Space, Module, $MessageInfer<Message["name"], Def, ReturnType<Def>, import("./message.infer").$MessageInputInfer<ReturnType<Def>, ReturnType<Def> extends infer T ? { [K in keyof T]: ReturnType<Def>[K] extends import("./template/message_template_field.builder").MessageTemplateFieldBuilder<any, any, infer I, any, any, infer Opt extends [undefined, undefined], infer Nul extends [null, null]> ? {
+        path: `${K & string}${keyof I & string}`;
+        data: I[keyof I];
+        opt: Opt[0];
+        nul: Nul[0];
+    } : never; } : never>, import("./message.infer").$MessageOutputInfer<ReturnType<Def>, ReturnType<Def> extends infer T_1 ? { [K_1 in keyof T_1]: ReturnType<Def>[K_1] extends import("./template/message_template_field.builder").MessageTemplateFieldBuilder<any, any, any, infer O, any, infer Opt_1 extends [undefined, undefined], infer Nul_1 extends [null, null]> ? {
+        path: `${K_1 & string}${keyof O & string}`;
+        data: O[keyof O];
+        opt: Opt_1[1];
+        nul: Nul_1[1];
+    } : never; } : never>>>;
+    static build(node: MessageBuilderNode, tree: ModuleTree, module: $Module): $Message;
+    static buildInlines(node: ResolvedBuilderNode, tree: ModuleTree, module: $Module): Record<string, $Message>;
+}
+export type AnyMessageBuilder = MessageBuilder<any, any, any>;
+export type MessageBuilderNode = ResolvedBuilderNode & {
+    builder: AnyMessageBuilder;
+    schema?: $Message;
+};

package/lib/elements/entities/message/message.builder.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageBuilder = void 0;
+const message_schema_1 = require("./message.schema");
+const message_template_schema_1 = require("./template/message_template.schema");
+const message_template_builder_1 = require("./template/message_template.builder");
+const message_template_field_builder_1 = require("./template/message_template_field.builder");
+class MessageBuilder {
+    constructor(module, name) {
+        this.module = module;
+        this.name = name;
+        this.$b = 'message';
+        this._template = new message_template_builder_1.MessageTemplateBuilder();
+    }
+    as(alias) {
+        this.alias = alias;
+        return this;
+    }
+    template($) {
+        const fieldBuilder = new message_template_field_builder_1.MessageTemplateFieldFactory(this.module);
+        const fields = $(fieldBuilder);
+        this._template.fields(fields);
+        return this;
+    }
+    // Build
+    static build(node, tree, module) {
+        node.schema = new message_schema_1.$Message(module.name, node.builder.name, node.builder.alias || node.builder.name, node.builder._template ? message_template_builder_1.MessageTemplateBuilder.build(node.builder._template, tree, module) : new message_template_schema_1.$MessageTemplate());
+        return node.schema;
+    }
+    // Build Inline
+    static buildInlines(node, tree, module) {
+        const nodeInlines = node.inlines.message || {};
+        const inlineMessages = {};
+        for (const name in nodeInlines || {}) {
+            const inline = nodeInlines[name];
+            inlineMessages[name] = MessageBuilder.build(inline, tree, module);
+        }
+        return inlineMessages;
+    }
+}
+exports.MessageBuilder = MessageBuilder;

package/lib/elements/entities/message/message.d.ts

@@ -0,0 +1,11 @@
+import { $Message as $Message } from './message.schema';
+export declare class Message<$ extends $Message> {
+    $: string;
+    private __meta__;
+    private constructor();
+    private sign;
+    getData(): Omit<this, "$" | "__meta__" | "getData">;
+    static new<$ extends $Message>($: string, data: $['#parsed'], sigKey?: string): Message<$> & $["#parsed"];
+    static clone<M extends Message<any>>(msg: M): Message<$Message>;
+}
+export type AnyMessage = Message<any>;

package/lib/elements/entities/message/message.infer.d.ts

@@ -0,0 +1,63 @@
+import { MessageTemplateFieldBuilder, MessageTemplateFieldBuilders } from './template/message_template_field.builder';
+import { MessageTemplateDef } from './template/message_template.builder';
+import { $Module } from "../../../schema";
+import { $Message } from './message.schema';
+export type $MessageInputInfer<Builder, Fields extends Record<string, {
+    path: any;
+    data: any;
+    opt: any;
+    nul: any;
+}> = {
+    [K in keyof Builder]: Builder[K] extends MessageTemplateFieldBuilder<any, any, infer I, any, any, infer Opt, infer Nul> ? {
+        path: `${K & string}${keyof I & string}`;
+        data: I[keyof I];
+        opt: Opt[0];
+        nul: Nul[0];
+    } : never;
+}> = {
+    [K in keyof Fields as Fields[K]['opt'] extends never ? Fields[K]['path'] : never]: Fields[K]['data'] | Fields[K]['nul'];
+} & {
+    [K in keyof Fields as Fields[K]['opt'] extends never ? never : Fields[K]['path']]?: Fields[K]['data'] | Fields[K]['nul'];
+};
+export type $MessageOutputInfer<Builder, Fields extends Record<string, {
+    path: any;
+    data: any;
+    opt: any;
+    nul: any;
+}> = {
+    [K in keyof Builder]: Builder[K] extends MessageTemplateFieldBuilder<any, any, any, infer O, any, infer Opt, infer Nul> ? {
+        path: `${K & string}${keyof O & string}`;
+        data: O[keyof O];
+        opt: Opt[1];
+        nul: Nul[1];
+    } : never;
+}> = {
+    [K in keyof Fields as Fields[K]['opt'] extends never ? Fields[K]['path'] : never]: Fields[K]['data'] | Fields[K]['nul'];
+} & {
+    [K in keyof Fields as Fields[K]['opt'] extends never ? never : Fields[K]['path']]?: Fields[K]['data'] | Fields[K]['nul'];
+};
+export interface $MessageInfer<Name extends string, Def extends MessageTemplateDef<any, any, any>, Builders extends MessageTemplateFieldBuilders = ReturnType<Def>, Raw = $MessageInputInfer<Builders>, Parsed = $MessageOutputInfer<Builders>> extends $Message {
+    name: Name;
+    '#raw': {
+        $: Name;
+    } & Raw;
+    '#parsed': {
+        $: Name;
+    } & Parsed;
+}
+export interface $MessageInferFromData<Name extends string, Data> extends $Message {
+    name: Name;
+    '#raw': {
+        $: Name;
+    } & Data;
+    '#parsed': {
+        $: Name;
+    } & Data;
+}
+export type $MessageTemplateBuilderInfer<Module extends $Module, Message extends $Message, Input, Output> = {
+    [K in Exclude<keyof Output, '$'>]: MessageTemplateFieldBuilder<Module, Message, {
+        '': Input[K & keyof Input];
+    }, {
+        '': Output[(K extends `${infer X}_id` ? X : K) & keyof Output];
+    }, {}>;
+};

package/lib/elements/entities/message/message.infer.js

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

package/lib/elements/entities/message/message.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Message = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+class Message {
+    constructor(_$, data, sigKey) {
+        this.$ = _$;
+        const { $, ...d } = data;
+        Object.assign(this, d);
+        this.__meta__ = {
+            sig: sigKey ? this.sign(data, sigKey) : undefined
+        };
+    }
+    sign(data, sigKey) {
+        function dump(obj) {
+            let str = '';
+            const keys = Object.keys(obj).sort();
+            for (const i in keys) {
+                str += keys[i] + ':';
+                const val = obj[keys[i]];
+                if (typeof val === 'object') {
+                    str += dump(val);
+                }
+                else {
+                    str += val.toString();
+                }
+                str += '\n';
+            }
+            return str;
+        }
+        const text = atob(dump(data));
+        return crypto_1.default.createHmac('sha1', sigKey)
+            .update(text)
+            .digest('hex');
+    }
+    getData() {
+        const { $, __meta__, ...data } = this;
+        return data;
+    }
+    static new($, data, sigKey) {
+        return new Message($, data, sigKey);
+    }
+    static clone(msg) {
+        const clone = new Message(msg.$, msg);
+        clone.__meta__ = msg.__meta__;
+        return clone;
+    }
+}
+exports.Message = Message;

package/lib/elements/entities/message/message.schema.d.ts

@@ -0,0 +1,15 @@
+import { $MessageTemplate } from './template/message_template.schema';
+export declare class $Message {
+    module: string;
+    name: string;
+    alias: string;
+    template: $MessageTemplate;
+    $t: "message";
+    '#raw': {
+        $: unknown;
+    };
+    '#parsed': {
+        $: unknown;
+    };
+    constructor(module: string, name: string, alias: string, template: $MessageTemplate);
+}

package/lib/elements/entities/message/message.schema.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$Message = void 0;
+class $Message {
+    constructor(module, name, alias, template) {
+        this.module = module;
+        this.name = name;
+        this.alias = alias;
+        this.template = template;
+        this.$t = 'message';
+    }
+}
+exports.$Message = $Message;

package/lib/elements/entities/message/message_parser.d.ts

@@ -0,0 +1,12 @@
+import { AnyTrxNode } from "../../../engine/transaction/trx_node";
+import { RawMessageInput } from "../../../schema";
+import { Message } from './message';
+import { $Message } from './message.schema';
+export declare class MessageParser<$ extends $Message> {
+    schema: $;
+    constructor(schema: $);
+    static parseWithTrxModule(trx: AnyTrxNode, raw: RawMessageInput<any, any>, sigKey?: string): Promise<any>;
+    parse(trx: AnyTrxNode, raw: $['#raw'], sigKey?: string): Promise<Message<$>>;
+    private sanitize;
+    private isEmpty;
+}

package/lib/elements/entities/message/message_parser.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageParser = void 0;
+const trx_node_1 = require("../../../engine/transaction/trx_node");
+const error_1 = require("../../../engine/data/error");
+const message_1 = require("./message");
+const log_1 = require("../../../engine/util/log");
+const message_template_parser_1 = require("./template/message_template_parser");
+class MessageParser {
+    constructor(schema) {
+        this.schema = schema;
+    }
+    static async parseWithTrxModule(trx, raw, sigKey) {
+        if (!raw.$) {
+            throw error_1.NesoiError.Message.NoType({ raw });
+        }
+        if (typeof raw.$ !== 'string') {
+            throw error_1.NesoiError.Message.InvalidType({ type: raw.$ });
+        }
+        const module = trx_node_1.TrxNode.getModule(trx);
+        const parser = module.messages[raw.$];
+        if (!parser) {
+            throw error_1.NesoiError.Message.NotSupportedByModule({ type: raw.$, module: module.name });
+        }
+        return parser.parse(trx, raw, sigKey);
+    }
+    // TODO: OPTIMIZATION
+    // Parse everything that's static first, then move on to
+    // parsing ids etc.
+    async parse(trx, raw, sigKey) {
+        log_1.Log.debug('trx', trx.globalId, `${(0, log_1.scopeTag)('message', this.schema.name)} Parse${sigKey ? ' (signed)' : ''}`, raw);
+        const parseFields = async (trx, fields, obj) => {
+            const parsedObj = {};
+            for (const k in fields) {
+                const field = fields[k];
+                const keyWithSuffix = field.type === 'id' ? `${k}_id` : k;
+                const parsedField = await parseField(trx, field, obj[keyWithSuffix]);
+                for (const suffix in parsedField) {
+                    parsedObj[field.name + suffix] = parsedField[suffix];
+                }
+            }
+            return parsedObj;
+        };
+        const parseField = async (trx, field, value) => {
+            // 1. Sanitize input
+            this.sanitize(value);
+            // 2. Check for required fields
+            if (this.isEmpty(value)) {
+                if (field.required) {
+                    throw error_1.NesoiError.Message.FieldIsRequired({ field: field.alias, path: field.path, value });
+                }
+                else if (field.defaultValue !== undefined) {
+                    value = field.defaultValue;
+                }
+                else {
+                    return { '': undefined };
+                }
+            }
+            if (field.array) {
+                if (!Array.isArray(value)) {
+                    throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value, type: 'list' });
+                }
+            }
+            // 3. Run parse method
+            let parsedValue;
+            try {
+                parsedValue = await (0, message_template_parser_1.MessageTemplateFieldParser)(raw, trx, field, value, parseFields);
+            }
+            catch (e) {
+                if (field.or) {
+                    return parseField(trx, field.or, value);
+                }
+                throw e;
+            }
+            // 4. Apply rules
+            for (const r in field.rules) {
+                const rule = field.rules[r];
+                const res = await rule({ field, value: parsedValue, raw });
+                if (typeof res === 'object') {
+                    parsedValue = res.set;
+                }
+                else if (res !== true) {
+                    throw error_1.NesoiError.Message.RuleFailed(rule, res);
+                }
+            }
+            return parsedValue;
+        };
+        const parsed = await parseFields(trx, this.schema.template.fields, raw);
+        return message_1.Message.new(this.schema.name, parsed, sigKey);
+    }
+    sanitize(value) {
+        if (typeof value === 'function') {
+            throw error_1.NesoiError.Message.UnsanitaryValue({
+                details: 'Functions not allowed as message inputs.'
+            });
+        }
+    }
+    isEmpty(value) {
+        // if (Array.isArray(value)) {
+        //     return value.length === 0
+        // }
+        //  if (typeof value === 'object') {
+        //     return Object.keys(value).length === 0
+        // }
+        if (typeof value === 'string') {
+            return value.length === 0;
+        }
+        return value === null ||
+            value === undefined;
+    }
+}
+exports.MessageParser = MessageParser;

package/lib/elements/entities/message/template/message_template.builder.d.ts

@@ -0,0 +1,14 @@
+import { $Module, $Space } from "../../../../schema";
+import { $MessageTemplate } from './message_template.schema';
+import { MessageTemplateFieldBuilders, MessageTemplateFieldFactory } from './message_template_field.builder';
+import { ModuleTree } from "../../../../engine/tree";
+export declare class MessageTemplateBuilder {
+    private _fields;
+    constructor();
+    fields(builders: MessageTemplateFieldBuilders): this;
+    static build(builder: MessageTemplateBuilder, tree: ModuleTree, module: $Module): $MessageTemplate;
+}
+export type MessageTemplateDef<Space extends $Space, Module extends $Module, MsgName extends keyof Module['messages']> = ($: MessageTemplateFieldFactory<Space, Module, MsgName>) => MessageTemplateFieldBuilders;
+export type MultiMessageTemplateDef<Space extends $Space, Module extends $Module> = ($: MessageTemplateFieldFactory<Space, Module, any>) => {
+    [x: string]: MessageTemplateFieldBuilders;
+};

package/lib/elements/entities/message/template/message_template.builder.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageTemplateBuilder = void 0;
+const message_template_schema_1 = require("./message_template.schema");
+const message_template_field_builder_1 = require("./message_template_field.builder");
+class MessageTemplateBuilder {
+    constructor() {
+        this._fields = {};
+    }
+    fields(builders) {
+        this._fields = builders;
+        return this;
+    }
+    /// Build
+    static build(builder, tree, module) {
+        const fields = message_template_field_builder_1.MessageTemplateFieldBuilder.buildChildren(builder._fields, tree, module);
+        return new message_template_schema_1.$MessageTemplate(fields);
+    }
+}
+exports.MessageTemplateBuilder = MessageTemplateBuilder;

package/lib/elements/entities/message/template/message_template.schema.d.ts

@@ -0,0 +1,57 @@
+import { $BucketModelFieldType } from "../../bucket/model/bucket_model.schema";
+import { $Dependency } from "../../../../engine/dependency";
+export type $MessageTemplateRule<I, Raw> = (def: {
+    field: $MessageTemplateField;
+    value: I;
+    raw: Raw;
+}) => {
+    set: I;
+} | true | string | Promise<{
+    set: I;
+} | true | string>;
+export type $MessageTemplateFieldMeta = {
+    decimal?: {
+        left?: number;
+        right?: number;
+    };
+    enum?: {
+        options: string | string[] | Record<string, any>;
+        dep?: $Dependency;
+    };
+    file?: {
+        maxSize?: number;
+        extnames?: string[];
+    };
+    id?: {
+        bucket: $Dependency;
+        view?: string;
+    };
+    msg?: $Dependency;
+};
+export type $MessageTemplateFieldType = $BucketModelFieldType | 'string_or_number' | 'id' | 'msg';
+export declare class $MessageTemplateField {
+    type: $MessageTemplateFieldType;
+    name: string;
+    alias: string;
+    path: string;
+    array: boolean;
+    required: boolean;
+    defaultValue: any;
+    nullable: boolean;
+    rules: $MessageTemplateRule<any, any>[];
+    meta: $MessageTemplateFieldMeta;
+    children?: $MessageTemplateFields | undefined;
+    or?: $MessageTemplateField | undefined;
+    '#raw': unknown;
+    '#parsed': unknown;
+    $t: string;
+    constructor(type: $MessageTemplateFieldType, name: string, alias: string, path: string, array: boolean, required: boolean, defaultValue: any, nullable: boolean, rules: $MessageTemplateRule<any, any>[], meta: $MessageTemplateFieldMeta, children?: $MessageTemplateFields | undefined, or?: $MessageTemplateField | undefined);
+}
+export type $MessageTemplateFields = {
+    [x: string]: $MessageTemplateField;
+};
+export declare class $MessageTemplate {
+    fields: $MessageTemplateFields;
+    $t: string;
+    constructor(fields?: $MessageTemplateFields);
+}

package/lib/elements/entities/message/template/message_template.schema.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$MessageTemplate = exports.$MessageTemplateField = void 0;
+class $MessageTemplateField {
+    constructor(type, name, alias, path, array, required, defaultValue, nullable, rules, meta, children, or) {
+        this.type = type;
+        this.name = name;
+        this.alias = alias;
+        this.path = path;
+        this.array = array;
+        this.required = required;
+        this.defaultValue = defaultValue;
+        this.nullable = nullable;
+        this.rules = rules;
+        this.meta = meta;
+        this.children = children;
+        this.or = or;
+        this.$t = 'message.template.field';
+    }
+}
+exports.$MessageTemplateField = $MessageTemplateField;
+class $MessageTemplate {
+    constructor(fields = {}) {
+        this.fields = fields;
+        this.$t = 'message.template';
+    }
+}
+exports.$MessageTemplate = $MessageTemplate;