nesoi 3.0.0

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

@@ -0,0 +1,225 @@
+import { $Module, $Space, BucketName, ViewName } from "../../../../schema";
+import { $MessageTemplateField, $MessageTemplateFieldMeta, $MessageTemplateFieldType, $MessageTemplateFields, $MessageTemplateRule } from './message_template.schema';
+import { $MessageInputInfer, $MessageOutputInfer, $MessageTemplateBuilderInfer } from '../message.infer';
+import { NesoiDate } from "../../../../engine/data/date";
+import { $Message } from '../message.schema';
+import { ModuleTree } from "../../../../engine/tree";
+import { NesoiObj } from "../../../../engine/data/obj";
+import { MessageEnumpath } from '../../constants/constants.schema';
+import { Decimal } from "../../../../engine/data/decimal";
+import { NesoiDatetime } from "../../../../engine/data/datetime";
+export declare class MessageTemplateFieldFactory<Space extends $Space, Module extends $Module, MsgName extends keyof Module['messages'], Message extends $Message = Module['messages'][MsgName]> {
+    private module;
+    private alias?;
+    constructor(module: string);
+    as(alias: string): Omit<typeof this, "as">;
+    get any(): MessageTemplateFieldBuilder<Module, Message, {
+        '': any;
+    }, {
+        '': any;
+    }, {}, [never, never], [never, never]>;
+    get boolean(): MessageTemplateFieldBuilder<Module, Message, {
+        '': boolean;
+    }, {
+        '': boolean;
+    }, {}, [never, never], [never, never]>;
+    get date(): MessageTemplateFieldBuilder<Module, Message, {
+        '': string;
+    }, {
+        '': NesoiDate;
+    }, {}, [never, never], [never, never]>;
+    get datetime(): MessageTemplateFieldBuilder<Module, Message, {
+        '': string;
+    }, {
+        '': NesoiDatetime;
+    }, {}, [never, never], [never, never]>;
+    decimal(config?: $MessageTemplateFieldMeta['decimal']): MessageTemplateFieldBuilder<Module, Message, {
+        '': string;
+    }, {
+        '': Decimal;
+    }, {}, [never, never], [never, never]>;
+    enum<Enumpaths extends MessageEnumpath<Module, Module['messages'][MsgName], Space['modules']>, Options extends (keyof Enumpaths & string) | readonly string[] | Record<string, any>>(options: Options): MessageTemplateFieldBuilder<Module, Message, {
+        '': (Options extends string ? keyof Enumpaths[Options & keyof Enumpaths]["options" & keyof Enumpaths[Options & keyof Enumpaths]] : Options extends (infer X)[] | readonly (infer X)[] ? X : keyof Options) & string;
+    }, {
+        '': (Options extends string ? keyof Enumpaths[Options & keyof Enumpaths]["options" & keyof Enumpaths[Options & keyof Enumpaths]] : Options extends (infer X)[] | readonly (infer X)[] ? X : keyof Options) & string;
+    }, {}, [never, never], [never, never]>;
+    file(config?: $MessageTemplateFieldMeta['file']): MessageTemplateFieldBuilder<Module, Message, {
+        '': File;
+    }, {
+        '': File;
+    }, {}, [never, never], [never, never]>;
+    get float(): MessageTemplateFieldBuilder<Module, Message, {
+        '': number;
+    }, {
+        '': number;
+    }, {}, [never, never], [never, never]>;
+    id<Name extends BucketName<Module>, View extends ViewName<Module['buckets'][Name]> | undefined>(bucket: Name, view?: View): MessageTemplateFieldBuilder<Module, Message, {
+        _id: (Module["buckets"][Name]["#data"] & NesoiObj)["id"];
+    }, {
+        '': undefined extends View ? Module["buckets"][Name]["#data"] : Module["buckets"][Name]["views"][NonNullable<View>]["#data"];
+    }, {}, [never, never], [never, never]>;
+    get int(): MessageTemplateFieldBuilder<Module, Message, {
+        '': number;
+    }, {
+        '': number;
+    }, {}, [never, never], [never, never]>;
+    get string(): MessageTemplateFieldBuilder<Module, Message, {
+        '': string;
+    }, {
+        '': string;
+    }, {}, [never, never], [never, never]>;
+    get string_or_number(): MessageTemplateFieldBuilder<Module, Message, {
+        '': string | number;
+    }, {
+        '': string | number;
+    }, {}, [never, never], [never, never]>;
+    obj<Builders extends MessageTemplateFieldBuilders>(children: Builders): MessageTemplateFieldBuilder<Module, Message, {
+        '': $MessageInputInfer<Builders>;
+    }, {
+        '': $MessageOutputInfer<Builders>;
+    }, Builders, [never, never], [never, never]>;
+    dict<Builder extends MessageTemplateFieldBuilder<Module, Message, any, any, any>>(item: Builder): MessageTemplateFieldBuilder<Module, Message, {
+        '': Record<string, Builder extends MessageTemplateFieldBuilder<any, any, infer X, any, any, [never, never], [never, never]> ? X[keyof X] : never>;
+    }, {
+        '': Record<string, Builder extends MessageTemplateFieldBuilder<any, any, any, infer X_1, any, [never, never], [never, never]> ? X_1[keyof X_1] : never>;
+    }, {
+        __dict: Builder;
+    }, [never, never], [never, never]>;
+    msg<MessageName extends keyof Module['messages'], Message extends Module['messages'][MessageName], Builders extends MessageTemplateFieldBuilders>(msg: MessageName, extra: Builders): MessageTemplateFieldBuilder<Module, Message, {
+        '': Omit<Message["#raw"], "$"> & {
+            $: any;
+        } & { [K_1 in keyof { [K in keyof Builders]: Builders[K] extends 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; } as { [K in keyof Builders]: Builders[K] extends 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; }[K_1]["opt"] extends never ? { [K in keyof Builders]: Builders[K] extends 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; }[K_1]["path"] : never]: { [K in keyof Builders]: Builders[K] extends 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; }[K_1]["data"] | { [K in keyof Builders]: Builders[K] extends 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; }[K_1]["nul"]; } & { [K_2 in keyof { [K in keyof Builders]: Builders[K] extends 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; } as { [K in keyof Builders]: Builders[K] extends 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; }[K_2]["opt"] extends never ? never : { [K in keyof Builders]: Builders[K] extends 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; }[K_2]["path"]]?: { [K in keyof Builders]: Builders[K] extends 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; }[K_2]["data"] | { [K in keyof Builders]: Builders[K] extends 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; }[K_2]["nul"] | undefined; };
+    }, {
+        '': Omit<Message["#parsed"], "$"> & {
+            $: any;
+        } & { [K_4 in keyof { [K_3 in keyof Builders]: Builders[K_3] extends MessageTemplateFieldBuilder<any, any, any, infer O, any, infer Opt_1 extends [undefined, undefined], infer Nul_1 extends [null, null]> ? {
+            path: `${K_3 & string}${keyof O & string}`;
+            data: O[keyof O];
+            opt: Opt_1[1];
+            nul: Nul_1[1];
+        } : never; } as { [K_3 in keyof Builders]: Builders[K_3] extends MessageTemplateFieldBuilder<any, any, any, infer O, any, infer Opt_1 extends [undefined, undefined], infer Nul_1 extends [null, null]> ? {
+            path: `${K_3 & string}${keyof O & string}`;
+            data: O[keyof O];
+            opt: Opt_1[1];
+            nul: Nul_1[1];
+        } : never; }[K_4]["opt"] extends never ? { [K_3 in keyof Builders]: Builders[K_3] extends MessageTemplateFieldBuilder<any, any, any, infer O, any, infer Opt_1 extends [undefined, undefined], infer Nul_1 extends [null, null]> ? {
+            path: `${K_3 & string}${keyof O & string}`;
+            data: O[keyof O];
+            opt: Opt_1[1];
+            nul: Nul_1[1];
+        } : never; }[K_4]["path"] : never]: { [K_3 in keyof Builders]: Builders[K_3] extends MessageTemplateFieldBuilder<any, any, any, infer O, any, infer Opt_1 extends [undefined, undefined], infer Nul_1 extends [null, null]> ? {
+            path: `${K_3 & string}${keyof O & string}`;
+            data: O[keyof O];
+            opt: Opt_1[1];
+            nul: Nul_1[1];
+        } : never; }[K_4]["data"] | { [K_3 in keyof Builders]: Builders[K_3] extends MessageTemplateFieldBuilder<any, any, any, infer O, any, infer Opt_1 extends [undefined, undefined], infer Nul_1 extends [null, null]> ? {
+            path: `${K_3 & string}${keyof O & string}`;
+            data: O[keyof O];
+            opt: Opt_1[1];
+            nul: Nul_1[1];
+        } : never; }[K_4]["nul"]; } & { [K_5 in keyof { [K_3 in keyof Builders]: Builders[K_3] extends MessageTemplateFieldBuilder<any, any, any, infer O, any, infer Opt_1 extends [undefined, undefined], infer Nul_1 extends [null, null]> ? {
+            path: `${K_3 & string}${keyof O & string}`;
+            data: O[keyof O];
+            opt: Opt_1[1];
+            nul: Nul_1[1];
+        } : never; } as { [K_3 in keyof Builders]: Builders[K_3] extends MessageTemplateFieldBuilder<any, any, any, infer O, any, infer Opt_1 extends [undefined, undefined], infer Nul_1 extends [null, null]> ? {
+            path: `${K_3 & string}${keyof O & string}`;
+            data: O[keyof O];
+            opt: Opt_1[1];
+            nul: Nul_1[1];
+        } : never; }[K_5]["opt"] extends never ? never : { [K_3 in keyof Builders]: Builders[K_3] extends MessageTemplateFieldBuilder<any, any, any, infer O, any, infer Opt_1 extends [undefined, undefined], infer Nul_1 extends [null, null]> ? {
+            path: `${K_3 & string}${keyof O & string}`;
+            data: O[keyof O];
+            opt: Opt_1[1];
+            nul: Nul_1[1];
+        } : never; }[K_5]["path"]]?: { [K_3 in keyof Builders]: Builders[K_3] extends MessageTemplateFieldBuilder<any, any, any, infer O, any, infer Opt_1 extends [undefined, undefined], infer Nul_1 extends [null, null]> ? {
+            path: `${K_3 & string}${keyof O & string}`;
+            data: O[keyof O];
+            opt: Opt_1[1];
+            nul: Nul_1[1];
+        } : never; }[K_5]["data"] | { [K_3 in keyof Builders]: Builders[K_3] extends MessageTemplateFieldBuilder<any, any, any, infer O, any, infer Opt_1 extends [undefined, undefined], infer Nul_1 extends [null, null]> ? {
+            path: `${K_3 & string}${keyof O & string}`;
+            data: O[keyof O];
+            opt: Opt_1[1];
+            nul: Nul_1[1];
+        } : never; }[K_5]["nul"] | undefined; };
+    }, {}, [never, never], [never, never]>;
+    extend<MsgName extends keyof Module['messages'], Builders extends MessageTemplateFieldBuilders>(name: MsgName, fields: Builders): $MessageTemplateBuilderInfer<Module, Module["messages"][MsgName], Module["messages"][MsgName]["#raw"], Module["messages"][MsgName]["#parsed"]> & Builders;
+}
+export declare class MessageTemplateFieldBuilder<Module extends $Module, Message extends $Message, DefinedInput, DefinedOutput, Children extends MessageTemplateFieldBuilders, Optional extends [undefined | never, undefined | never] = [never, never], // Used to infer the message type
+Nullable extends [null | never, null | never] = [never, never]> {
+    private type;
+    private value;
+    private alias?;
+    private children?;
+    private _array;
+    private _required;
+    private _defaultValue?;
+    private _nullable;
+    private _rules;
+    private _or?;
+    constructor(type: $MessageTemplateFieldType, value: $MessageTemplateFieldMeta, alias?: string | undefined, children?: Children | undefined);
+    as(alias: string): this;
+    get optional(): MessageTemplateFieldBuilder<Module, Message, DefinedInput, DefinedOutput, Children, [undefined, undefined], Nullable>;
+    default(value: DefinedInput[keyof DefinedInput] | Nullable[0]): MessageTemplateFieldBuilder<Module, Message, DefinedInput, DefinedOutput, Children, [undefined, never], Nullable>;
+    get nullable(): MessageTemplateFieldBuilder<Module, Message, DefinedInput, DefinedOutput, Children, Optional, [null, null]>;
+    rule(rule: $MessageTemplateRule<DefinedInput[keyof DefinedInput], Message['#raw']>): this;
+    get array(): MessageTemplateFieldBuilder<Module, Message, { [K in keyof DefinedInput]: DefinedInput[K][]; }, { [K in keyof DefinedOutput]: DefinedOutput[K][]; }, Children, Optional, Nullable>;
+    or<Def extends AnyMessageTemplateFieldBuilder>(def: Def): MessageTemplateFieldBuilder<Module, Message, { [K in keyof DefinedInput]: DefinedInput[K] | (Def extends MessageTemplateFieldBuilder<any, any, infer X, any, any, [never, never], [never, never]> ? X : never)[keyof (Def extends MessageTemplateFieldBuilder<any, any, infer X, any, any, [never, never], [never, never]> ? X : never)]; }, { [K in keyof DefinedOutput]: DefinedOutput[K] | (Def extends MessageTemplateFieldBuilder<any, any, any, infer X, any, [never, never], [never, never]> ? X : never)[keyof (Def extends MessageTemplateFieldBuilder<any, any, any, infer X, any, [never, never], [never, never]> ? X : never)]; }, Children, Optional, Nullable>;
+    static build(builder: AnyMessageTemplateFieldBuilder, name: string, tree: ModuleTree, module: $Module, basePath: string): $MessageTemplateField;
+    static buildChildren(fields: MessageTemplateFieldBuilders, tree: ModuleTree, module: $Module, basePath?: string): $MessageTemplateFields;
+}
+export type MessageTemplateFieldBuilders = {
+    [x: string]: AnyMessageTemplateFieldBuilder;
+};
+export type AnyMessageTemplateFieldBuilder = MessageTemplateFieldBuilder<any, any, any, any, any>;

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

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageTemplateFieldBuilder = exports.MessageTemplateFieldFactory = void 0;
+const message_template_schema_1 = require("./message_template.schema");
+const error_1 = require("../../../../engine/data/error");
+const dependency_1 = require("../../../../engine/dependency");
+class MessageTemplateFieldFactory {
+    constructor(module) {
+        this.module = module;
+    }
+    as(alias) {
+        this.alias = alias;
+        return this;
+    }
+    get any() {
+        return new MessageTemplateFieldBuilder('unknown', {}, this.alias);
+    }
+    get boolean() {
+        return new MessageTemplateFieldBuilder('boolean', {}, this.alias);
+    }
+    get date() {
+        return new MessageTemplateFieldBuilder('date', {}, this.alias);
+    }
+    get datetime() {
+        return new MessageTemplateFieldBuilder('datetime', {}, this.alias);
+    }
+    decimal(config) {
+        return new MessageTemplateFieldBuilder('decimal', { decimal: config }, this.alias);
+    }
+    enum(options) {
+        let dep;
+        if (typeof options === 'string') {
+            const tag = dependency_1.$Tag.parseOrFail(options);
+            if (tag.module) {
+                dep = new dependency_1.$Dependency(this.module, 'constants', `${tag.module}::*`);
+            }
+            else {
+                dep = new dependency_1.$Dependency(this.module, 'constants', '*');
+            }
+        }
+        return new MessageTemplateFieldBuilder('enum', { enum: { options, dep } }, this.alias, undefined);
+    }
+    file(config) {
+        return new MessageTemplateFieldBuilder('file', { file: config }, this.alias);
+    }
+    get float() {
+        return new MessageTemplateFieldBuilder('float', {}, this.alias);
+    }
+    id(bucket, view) {
+        // Module and tag are updated on build
+        const ref = new dependency_1.$Dependency(this.module, 'bucket', bucket);
+        return new MessageTemplateFieldBuilder('id', { id: { bucket: ref, view: view } }, this.alias, undefined);
+    }
+    get int() {
+        return new MessageTemplateFieldBuilder('int', {}, this.alias);
+    }
+    get string() {
+        return new MessageTemplateFieldBuilder('string', {}, this.alias);
+    }
+    get string_or_number() {
+        return new MessageTemplateFieldBuilder('string_or_number', {}, this.alias);
+    }
+    obj(children) {
+        return new MessageTemplateFieldBuilder('obj', {}, this.alias, children);
+    }
+    dict(item) {
+        return new MessageTemplateFieldBuilder('dict', {}, this.alias, { __dict: item });
+    }
+    msg(msg, extra) {
+        // Module and tag are updated on build
+        const ref = new dependency_1.$Dependency(this.module, 'message', msg);
+        return new MessageTemplateFieldBuilder('msg', { msg: ref }, this.alias, extra);
+    }
+    extend(name, fields) {
+        const ref = new dependency_1.$Dependency(this.module, 'message', name);
+        return {
+            __ext: ref,
+            ...fields
+        };
+    }
+}
+exports.MessageTemplateFieldFactory = MessageTemplateFieldFactory;
+class MessageTemplateFieldBuilder {
+    constructor(type, value, alias, children) {
+        this.type = type;
+        this.value = value;
+        this.alias = alias;
+        this.children = children;
+        this._array = false;
+        this._required = true;
+        this._defaultValue = undefined;
+        this._nullable = true;
+        this._rules = [];
+    }
+    as(alias) {
+        this.alias = alias;
+        return this;
+    }
+    get optional() {
+        this._required = false;
+        return this;
+    }
+    default(value) {
+        this._required = false;
+        this._defaultValue = value;
+        return this;
+    }
+    get nullable() {
+        this._nullable = true;
+        return this;
+    }
+    rule(rule) {
+        this._rules.push(rule);
+        return this;
+    }
+    get array() {
+        this._array = true;
+        return this;
+    }
+    or(def) {
+        this._or = def;
+        return this;
+    }
+    // Build
+    static build(builder, name, tree, module, basePath) {
+        const or = builder._or
+            ? this.build(builder._or, name, tree, module, basePath)
+            : undefined;
+        const path = basePath + name + (builder.type === 'id' ? '_id' : '') + '.';
+        const childrenBasePath = builder.children
+            ? path + (builder._array ? '*.' : '')
+            : undefined;
+        return new message_template_schema_1.$MessageTemplateField(builder.type, name, builder.alias || name, basePath + name, builder._array, builder._required, builder._defaultValue, builder._nullable, builder._rules, builder.value, builder.children ? MessageTemplateFieldBuilder.buildChildren(builder.children, tree, module, childrenBasePath) : undefined, or);
+    }
+    static buildChildren(fields, tree, module, basePath = '') {
+        const schema = {};
+        for (const c in fields) {
+            const child = fields[c];
+            // Extended fields inherit from other messages
+            if (child.__ext) {
+                const ext = tree.getSchema(child.__ext);
+                schema[c].children = Object.assign({}, ext.template.fields, schema[c].children || {});
+                continue;
+            }
+            const param = c;
+            // A .msg() parameter is an obj which takes fields from
+            // another message
+            if (child.type === 'msg') {
+                const name = child.value.msg.name;
+                const $msg = module.messages[name];
+                if (!$msg) {
+                    throw error_1.NesoiError.Builder.Message.UnknownModuleMessage(name);
+                }
+                const builder = new MessageTemplateFieldFactory(module.name).obj({});
+                builder.alias = child.alias;
+                builder._required = child._required;
+                builder._defaultValue = child._defaultValue;
+                builder._nullable = child._nullable;
+                builder._rules = child._rules.slice(0, -1);
+                builder.children = child.children;
+                schema[param] = MessageTemplateFieldBuilder.build(builder, c, tree, module, basePath);
+                schema[param].children = schema[param].children || {};
+                Object.assign(schema[param].children, $msg.template.fields);
+                continue;
+            }
+            // All other parameters are built directly
+            schema[param] = MessageTemplateFieldBuilder.build(child, c, tree, module, basePath);
+        }
+        return schema;
+    }
+}
+exports.MessageTemplateFieldBuilder = MessageTemplateFieldBuilder;

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

@@ -0,0 +1,3 @@
+import { $MessageTemplateField, $MessageTemplateFields } from './message_template.schema';
+import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
+export declare function MessageTemplateFieldParser(raw: Record<string, any>, trx: AnyTrxNode, field: $MessageTemplateField, value: any, parseFields: (trx: AnyTrxNode, fields: $MessageTemplateFields, obj: Record<string, any>) => any): Promise<Record<string, any>>;

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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageTemplateFieldParser = MessageTemplateFieldParser;
+const parse_1 = require("../../../../engine/util/parse");
+const error_1 = require("../../../../engine/data/error");
+async function MessageTemplateFieldParser(raw, trx, field, value, parseFields) {
+    if (field.type === 'unknown') {
+        return {
+            '': value
+        };
+    }
+    if (field.type === 'boolean') {
+        return {
+            '': await (0, parse_1.parseBoolean)(field, value, field.array)
+        };
+    }
+    if (field.type === 'date') {
+        return {
+            '': await (0, parse_1.parseDate)(field, value, field.array)
+        };
+    }
+    if (field.type === 'datetime') {
+        return {
+            '': await (0, parse_1.parseDatetime)(field, value, field.array)
+        };
+    }
+    if (field.type === 'decimal') {
+        return {
+            '': await (0, parse_1.parseDecimal)(field, value, field.array)
+        };
+    }
+    if (field.type === 'enum') {
+        const options = field.meta.enum.options;
+        return {
+            '': await (0, parse_1.parseEnum)(raw, field, value, field.array, options, trx)
+        };
+    }
+    if (field.type === 'file') {
+        const config = field.meta.file;
+        return {
+            '': await (0, parse_1.parseFile)(field, value, field.array, config)
+        };
+    }
+    if (field.type === 'float') {
+        return {
+            '': await (0, parse_1.parseFloat_)(field, value, field.array)
+        };
+    }
+    if (field.type === 'id') {
+        const bucket = field.meta.id.bucket;
+        const view = field.meta.id.view;
+        const parsed = await (0, parse_1.parseId)(field, value, field.array, trx, bucket.refName, view);
+        return {
+            '': parsed.obj
+        };
+    }
+    if (field.type === 'int') {
+        return {
+            '': await (0, parse_1.parseInt_)(field, value, field.array)
+        };
+    }
+    if (field.type === 'string') {
+        return {
+            '': await (0, parse_1.parseString)(field, value, field.array)
+        };
+    }
+    if (field.type === 'string_or_number') {
+        return {
+            '': await (0, parse_1.parseStringOrNumber)(field, value, field.array)
+        };
+    }
+    if (field.type === 'obj') {
+        return {
+            '': await (0, parse_1.parseObj)(field, value, field.array, trx, parseFields)
+        };
+    }
+    if (field.type === 'dict') {
+        return {
+            '': await (0, parse_1.parseDict)(field, value, field.array, trx, parseFields)
+        };
+    }
+    throw error_1.NesoiError.Builder.Message.UnknownTemplateFieldType(field.type);
+}

package/lib/elements/index.d.ts

@@ -0,0 +1,11 @@
+export { MemoryBucketAdapter } from './entities/bucket/adapters/memory.bucket_adapter';
+export { $Controller } from './edge/controller/controller.schema';
+export { $Machine } from './blocks/machine/machine.schema';
+export { $Constants } from './entities/constants/constants.schema';
+export { $Message } from './entities/message/message.schema';
+export { $Bucket } from './entities/bucket/bucket.schema';
+export { $Job } from './blocks/job/job.schema';
+export { $Resource } from './blocks/resource/resource.schema';
+export { $Queue } from './blocks/queue/queue.schema';
+export { $Externals } from './blocks/externals/externals.schema';
+export { $Space, $Module } from '../schema';

package/lib/elements/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$Externals = exports.$Queue = exports.$Resource = exports.$Job = exports.$Bucket = exports.$Message = exports.$Constants = exports.$Machine = exports.$Controller = exports.MemoryBucketAdapter = void 0;
+var memory_bucket_adapter_1 = require("./entities/bucket/adapters/memory.bucket_adapter");
+Object.defineProperty(exports, "MemoryBucketAdapter", { enumerable: true, get: function () { return memory_bucket_adapter_1.MemoryBucketAdapter; } });
+var controller_schema_1 = require("./edge/controller/controller.schema");
+Object.defineProperty(exports, "$Controller", { enumerable: true, get: function () { return controller_schema_1.$Controller; } });
+var machine_schema_1 = require("./blocks/machine/machine.schema");
+Object.defineProperty(exports, "$Machine", { enumerable: true, get: function () { return machine_schema_1.$Machine; } });
+var constants_schema_1 = require("./entities/constants/constants.schema");
+Object.defineProperty(exports, "$Constants", { enumerable: true, get: function () { return constants_schema_1.$Constants; } });
+var message_schema_1 = require("./entities/message/message.schema");
+Object.defineProperty(exports, "$Message", { enumerable: true, get: function () { return message_schema_1.$Message; } });
+var bucket_schema_1 = require("./entities/bucket/bucket.schema");
+Object.defineProperty(exports, "$Bucket", { enumerable: true, get: function () { return bucket_schema_1.$Bucket; } });
+var job_schema_1 = require("./blocks/job/job.schema");
+Object.defineProperty(exports, "$Job", { enumerable: true, get: function () { return job_schema_1.$Job; } });
+var resource_schema_1 = require("./blocks/resource/resource.schema");
+Object.defineProperty(exports, "$Resource", { enumerable: true, get: function () { return resource_schema_1.$Resource; } });
+var queue_schema_1 = require("./blocks/queue/queue.schema");
+Object.defineProperty(exports, "$Queue", { enumerable: true, get: function () { return queue_schema_1.$Queue; } });
+var externals_schema_1 = require("./blocks/externals/externals.schema");
+Object.defineProperty(exports, "$Externals", { enumerable: true, get: function () { return externals_schema_1.$Externals; } });

package/lib/engine/apps/app.config.d.ts

@@ -0,0 +1,49 @@
+import { $Space, ModuleName } from "../../schema";
+import { BucketConfig } from "../../elements/entities/bucket/bucket.config";
+import { AuthnProvider } from '../auth/authn';
+import { ControllerConfig } from "../../elements/edge/controller/controller.config";
+import { TrxEngineConfig } from '../transaction/trx_engine.config';
+import { CompilerConfig } from "../../compiler/compiler";
+import { App } from './app';
+import { CLIConfig } from '../cli/cli';
+export type AppConfig<S extends $Space, Modules extends ModuleName<S>> = {
+    i18n?: AppI18nConfig;
+    authn?: AppAuthnConfig<S>;
+    buckets?: AppBucketConfig<S, Modules, any>;
+    controllers?: AppControllerConfig<S, Modules, any>;
+    cli?: CLIConfig<any>;
+    compiler?: CompilerConfig;
+    trxEngine?: AppTrxEngineConfig<S, Modules, any>;
+};
+export type AnyAppConfig = AppConfig<any, any>;
+export type AppI18nConfig = {
+    [x: string]: ($: Record<string, any>) => string;
+};
+export type AppAuthnConfig<S extends $Space> = {
+    [K in keyof S['authnUsers']]: AuthnProvider<S['authnUsers'][K]>;
+};
+export type AppBucketConfig<S extends $Space, Modules extends ModuleName<S>, Providers extends Record<string, any>> = Partial<{
+    [M in (Modules & keyof S['modules'])]: Partial<{
+        [K in keyof S['modules'][M]['buckets']]: BucketConfig<S['modules'][M]['buckets'][K], Providers>;
+    }>;
+}>;
+export type AppControllerConfig<S extends $Space, Modules extends ModuleName<S>, Providers extends Record<string, any>> = Partial<{
+    [M in (Modules & keyof S['modules'])]: Partial<{
+        [K in keyof S['modules'][M]['controllers']]: ControllerConfig<S['modules'][M]['controllers'][K], Providers>;
+    }>;
+}>;
+export type AppTrxEngineConfig<S extends $Space, Modules extends ModuleName<S>, Providers extends Record<string, any>> = Partial<{
+    [M in (Modules & keyof S['modules'])]: TrxEngineConfig<S, S['modules'][M], any, Providers>;
+}>;
+export declare class AppConfigFactory<S extends $Space, Modules extends string = ModuleName<S> & string, Providers extends Record<string, any> = Record<string, any>> {
+    private app;
+    private config;
+    constructor(app: App<S, Modules, Providers>);
+    i18n(config: AppI18nConfig): App<S, Modules, Providers>;
+    authn(config: AppAuthnConfig<S>): App<S, Modules, Providers>;
+    buckets(config: AppBucketConfig<S, Modules, Providers>): App<S, Modules, Providers>;
+    controllers(config: AppControllerConfig<S, Modules, Providers>): App<S, Modules, Providers>;
+    compiler(config: CompilerConfig): App<S, Modules, Providers>;
+    cli(config: CLIConfig<Providers>): App<S, Modules, Providers>;
+    trx(config: AppTrxEngineConfig<S, Modules, Providers>): App<S, Modules, Providers>;
+}

package/lib/engine/apps/app.config.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppConfigFactory = void 0;
+class AppConfigFactory {
+    constructor(app) {
+        this.app = app;
+        this.config = app._config;
+    }
+    i18n(config) {
+        this.config.i18n = config;
+        return this.app;
+    }
+    authn(config) {
+        this.config.authn = config;
+        return this.app;
+    }
+    buckets(config) {
+        this.config.buckets = config;
+        return this.app;
+    }
+    controllers(config) {
+        this.config.controllers = config;
+        return this.app;
+    }
+    compiler(config) {
+        this.config.compiler = config;
+        return this.app;
+    }
+    cli(config) {
+        this.config.cli = config;
+        return this.app;
+    }
+    trx(config) {
+        this.config.trxEngine = config;
+        return this.app;
+    }
+}
+exports.AppConfigFactory = AppConfigFactory;