nesoi 3.0.17 → 3.0.19

package/lib/compiler/elements/bucket.element.d.ts

@@ -14,7 +14,7 @@ export declare class BucketElement extends Element<$Bucket> {
     private buildModelFieldType;
     private buildCompositionType;
     buildModelType(fields?: $BucketModelFields): ObjTypeAsObj;
-    buildModelFieldNamesType(model: ObjTypeAsObj, fields?: $BucketModelFields, path?: string): Record<string, TypeAsObj>;
+    buildModelFieldNamesType(model: ObjTypeAsObj, fields?: $BucketModelFields): Record<string, TypeAsObj>;
     private buildGraphType;
     private buildViewsType;
     private buildViewType;

package/lib/compiler/elements/bucket.element.js

@@ -64,7 +64,7 @@ class BucketElement extends element_1.Element {
             bucket
         };
     }
-    buildModelFieldType(field) {
+    buildModelFieldType(field, isUnion = false) {
         let type = 'unknown';
         if (field.type === 'boolean') {
             type = 'boolean';
@@ -119,35 +119,38 @@ class BucketElement extends element_1.Element {
                 '[x in string]': field.children.__dict
             });
         }
-        if (!field.required && field.defaultValue === undefined) {
-            if (typeof type === 'object') {
-                type.__optional = true;
-            }
-            else {
-                type += ' | undefined';
-            }
-        }
-        if (field.array) {
-            if (typeof type === 'object') {
-                type.__array = true;
-            }
-            else {
-                type += '[]';
-            }
-        }
         if (field.or) {
-            const orType = this.buildModelFieldType(field.or);
+            const orType = this.buildModelFieldType(field.or, true);
             if (typeof type === 'object') {
                 type.__or = orType;
             }
             else if (typeof orType === 'object') {
+                const nonObj = type;
                 type = orType;
-                type.__or = orType;
+                type.__or = nonObj;
             }
             else {
                 type = `${type} | ${orType}`;
             }
         }
+        if (!isUnion) {
+            if (!field.required && field.defaultValue === undefined) {
+                if (typeof type === 'object') {
+                    type.__optional = true;
+                }
+                else {
+                    type = `(${type}) | undefined`;
+                }
+            }
+            if (field.array) {
+                if (typeof type === 'object') {
+                    type.__array = true;
+                }
+                else {
+                    type = `(${type})[]`;
+                }
+            }
+        }
         return type;
     }
     buildCompositionType() {
@@ -171,25 +174,20 @@ class BucketElement extends element_1.Element {
         });
         return model;
     }
-    buildModelFieldNamesType(model, fields = this.schema.model.fields, path) {
+    buildModelFieldNamesType(model, fields = this.schema.model.fields) {
         const fieldPaths = {};
         Object.entries(fields).forEach(([key, field]) => {
             if (key === '__dict') {
                 return;
             }
-            const keyPath = (path ? path + '.' : '') + key;
-            fieldPaths[keyPath] = model[key];
+            fieldPaths[field.path] = model[key];
             if (field.children) {
                 let nextFields = field.children;
-                let nextKey = keyPath;
                 if ('__dict' in field.children) {
                     nextFields = field.children.__dict.children;
-                    nextKey += '.#';
                 }
-                if (field.array)
-                    nextKey += '.#';
                 if (nextFields) {
-                    Object.assign(fieldPaths, this.buildModelFieldNamesType(model[key], nextFields, nextKey));
+                    Object.assign(fieldPaths, this.buildModelFieldNamesType(model[key], nextFields));
                 }
             }
         });

package/lib/compiler/elements/message.element.js

@@ -44,7 +44,7 @@ class MessageElement extends element_1.Element {
     buildIO(fields = this.schema.template.fields) {
         const input = {};
         const output = {};
-        Object.entries(fields).forEach(([key, field]) => {
+        const buildField = (key, field, isUnion = false) => {
             if (field.type === 'boolean') {
                 input[key] = 'boolean';
                 output[key] = 'boolean';
@@ -138,36 +138,66 @@ class MessageElement extends element_1.Element {
                 input[key] = 'unknown';
                 output[key] = 'unknown';
             }
-            if (!field.required) {
+            if (field.or) {
+                const orType = buildField(key, field.or, true);
                 if (typeof input[key] === 'object') {
-                    input[key].__optional = true;
+                    input[key].__or = orType;
+                }
+                else if (typeof orType === 'object') {
+                    const nonObj = input[key];
+                    input[key] = orType;
+                    input[key].__or = nonObj;
                 }
                 else {
-                    input[key] += ' | undefined';
+                    input[key] = `${input[key]} | ${orType}`;
                 }
-                if (field.defaultValue === undefined) {
-                    if (typeof output[key] === 'object') {
-                        output[key].__optional = true;
-                    }
-                    else {
-                        output[key] += ' | undefined';
-                    }
+                if (typeof output[key] === 'object') {
+                    output[key].__or = orType;
                 }
-            }
-            if (field.array) {
-                if (typeof input[key] === 'object') {
-                    input[key].__array = true;
+                else if (typeof orType === 'object') {
+                    const nonObj = output[key];
+                    output[key] = orType;
+                    output[key].__or = nonObj;
                 }
                 else {
-                    input[key] += '[]';
+                    output[key] = `${output[key]} | ${orType}`;
                 }
-                if (typeof output[key] === 'object') {
-                    output[key].__array = true;
+            }
+            if (!isUnion) {
+                if (!field.required) {
+                    if (typeof input[key] === 'object') {
+                        input[key].__optional = true;
+                    }
+                    else {
+                        input[key] = `(${input[key]}) | undefined`;
+                    }
+                    if (field.defaultValue === undefined) {
+                        if (typeof output[key] === 'object') {
+                            output[key].__optional = true;
+                        }
+                        else {
+                            output[key] = `(${output[key]}) | undefined`;
+                        }
+                    }
                 }
-                else {
-                    output[key] += '[]';
+                if (field.array) {
+                    if (typeof input[key] === 'object') {
+                        input[key].__array = true;
+                    }
+                    else {
+                        input[key] = `(${input[key]})[]`;
+                    }
+                    if (typeof output[key] === 'object') {
+                        output[key].__array = true;
+                    }
+                    else {
+                        output[key] = `(${output[key]})[]`;
+                    }
                 }
             }
+        };
+        Object.entries(fields).forEach(([key, field]) => {
+            buildField(key, field);
         });
         return { input, output };
     }

package/lib/elements/entities/bucket/model/bucket_model.convert.js

@@ -35,21 +35,23 @@ function convertToView(model, name, fields = model.fields, path) {
  * @subcategory Entity
  * */
 function convertToMessage(module, model, name, alias, include = [], exclude = []) {
+    const convertField = (field) => {
+        return new message_template_schema_1.$MessageTemplateField(field.type, field.name, field.alias, field.path, field.path, field.array, field.required, undefined, false, [], {
+            enum: field.meta?.enum ? {
+                options: field.meta.enum.options,
+                dep: field.meta.enum.dep ? new dependency_1.$Dependency(module, 'constants', `${field.meta.enum.dep.module}::${field.meta.enum.dep.name}`) : undefined
+            } : undefined
+        }, field.children ? convertFields(field.children, include, exclude) : undefined, field.or ? convertField(field.or) : undefined);
+    };
     const convertFields = (fields, include = [], exclude = [], root = '') => {
         const msgFields = {};
         for (const f in fields) {
             const field = fields[f];
-            const path = root.length ? `${root}.${f}` : f;
-            if ((include.length && !include.includes(path))
-                || exclude.includes(path)) {
+            if ((include.length && !include.includes(field.path))
+                || exclude.includes(field.path)) {
                 continue;
             }
-            msgFields[f] = new message_template_schema_1.$MessageTemplateField(field.type, field.name, field.alias, path, field.array, field.required, undefined, false, [], {
-                enum: field.meta?.enum ? {
-                    options: field.meta.enum.options,
-                    dep: field.meta.enum.dep ? new dependency_1.$Dependency(module, 'constants', `${field.meta.enum.dep.module}::${field.meta.enum.dep.name}`) : undefined
-                } : undefined
-            }, field.children ? convertFields(field.children, include, exclude) : undefined);
+            msgFields[f] = convertField(field);
         }
         return msgFields;
     };

package/lib/elements/entities/bucket/model/bucket_model_field.builder.d.ts

@@ -132,7 +132,7 @@ export declare class BucketModelFieldBuilder<Module extends $Module, DefinedData
      */
     maxLength(val: number | null): void;
     encrypt(key: keyof Module['constants']['values'], algorithm?: string): void;
-    static build(builder: BucketModelFieldBuilder<any, any>, name: string, path?: string): {
+    static build(builder: BucketModelFieldBuilder<any, any>, name: string, basePath?: string): {
         schema: $BucketModelField;
         hasFile: boolean;
         hasEncrypted: boolean;

package/lib/elements/entities/bucket/model/bucket_model_field.builder.js

@@ -129,11 +129,15 @@ class BucketModelFieldBuilder {
     }
     get array() {
         this._array = true;
+        if (this._or) {
+            // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+            this._or.array;
+        }
         return this;
     }
     or(def) {
-        this._or = def;
-        return this;
+        def._or = this;
+        return def;
     }
     /**
      * This can be applied to `string` and `enum` fields,
@@ -153,18 +157,17 @@ class BucketModelFieldBuilder {
         };
     }
     // Build
-    static build(builder, name, path = '') {
-        path += name;
+    static build(builder, name, basePath = '') {
+        const path = basePath + name;
+        const itemPath = builder._array ? path + '.#.' : path + '.';
         const children = builder.children
-            ? BucketModelFieldBuilder.buildChildren(builder.module, builder.children, builder._array
-                ? path + '.#.'
-                : path + '.')
+            ? BucketModelFieldBuilder.buildChildren(builder.module, builder.children, itemPath)
             : undefined;
         const defaults = builder._defaultValue && builder.children
             ? Object.assign({}, builder._defaultValue, children?.defaults)
             : builder._defaultValue;
         const or = builder._or
-            ? this.build(builder._or, name)
+            ? this.build(builder._or, name, basePath)
             : undefined;
         const schema = new bucket_model_schema_1.$BucketModelField(name, path, builder.type, builder.alias || name, builder._array, builder._required, builder.meta, defaults, children?.schema, or?.schema, builder.crypto);
         const hasFile = builder.type === 'file'

package/lib/elements/entities/bucket/view/bucket_view.js

@@ -95,7 +95,6 @@ class BucketView {
                 }
                 parsedObj[k] = await doParse(prop.children || {}, index);
             }
-            parsedObj['$v'] = this.schema.name;
             return parsedObj;
         };
         const parseModelProp = async (obj, prop, index, key) => {
@@ -129,7 +128,8 @@ class BucketView {
             }
             return rawValue;
         };
-        const parsedObj = await doParse(this.schema.fields, '*');
+        const parsedObj = await doParse(this.schema.fields);
+        parsedObj['$v'] = this.schema.name;
         return {
             id: raw.id,
             ...parsedObj

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

@@ -12,9 +12,5 @@ export declare class MessageParser<$ extends $Message> {
     static parseWithTrxModule(trx: AnyTrxNode, raw: RawMessageInput<any, any>, sigKey?: string): Promise<any>;
     parse(trx: AnyTrxNode, raw: $['#raw'], sigKey?: string): Promise<Message<$>>;
     private sanitize;
-    /**
-     * Empty values: `{}`, `[]`, `''`, `null`, `undefined`
-     */
-    static isEmpty(value: any): boolean;
 }
 export type AnyMessageParser = MessageParser<$Message>;

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

@@ -37,11 +37,7 @@ class MessageParser {
             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];
-                }
+                parsedObj[k] = await parseField(trx, field, obj[k]);
             }
             return parsedObj;
         };
@@ -49,40 +45,7 @@ class MessageParser {
             // 1. Sanitize input
             this.sanitize(value);
             // 2. Check for required fields
-            let parsedValue;
-            if (MessageParser.isEmpty(value)) {
-                if (field.required) {
-                    const pathWithSuffix = field.type === 'id' ? `${field.path}_id` : field.path;
-                    throw error_1.NesoiError.Message.FieldIsRequired({ field: field.alias, path: pathWithSuffix, value });
-                }
-                else if (field.defaultValue !== undefined) {
-                    parsedValue = { '': field.defaultValue };
-                }
-                else {
-                    parsedValue = { '': undefined };
-                }
-            }
-            else {
-                if (field.array) {
-                    if (!Array.isArray(value)) {
-                        throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value, type: 'list' });
-                    }
-                }
-                // 3. Run parse method
-                try {
-                    parsedValue = await (0, message_template_parser_1.MessageTemplateFieldParser)(raw, trx, field, value, parseFields);
-                }
-                catch (e) {
-                    // If this error was not triggered by a nested field,
-                    // and we have another option, we try that option.
-                    if (field.or && !e.__msg_deep_error) {
-                        return parseField(trx, field.or, value);
-                    }
-                    e.__msg_deep_error = true;
-                    throw e;
-                }
-            }
-            return parsedValue;
+            return (0, message_template_parser_1.MessageTemplateFieldParser)(raw, trx, field, value);
         };
         const applyRules = async (fields, parsed, parsedValue = parsed) => {
             for (const f in fields) {
@@ -115,23 +78,5 @@ class MessageParser {
             });
         }
     }
-    /**
-     * Empty values: `{}`, `[]`, `''`, `null`, `undefined`
-     */
-    static isEmpty(value) {
-        if (value === null || value === undefined) {
-            return true;
-        }
-        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 false;
-    }
 }
 exports.MessageParser = MessageParser;

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

@@ -39,7 +39,8 @@ export declare class $MessageTemplateField {
     type: $MessageTemplateFieldType;
     name: string;
     alias: string;
-    path: string;
+    path_raw: string;
+    path_parsed: string;
     array: boolean;
     required: boolean;
     defaultValue: any;
@@ -51,7 +52,7 @@ export declare class $MessageTemplateField {
     '#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[], meta: $MessageTemplateFieldMeta, children?: $MessageTemplateFields | undefined, or?: $MessageTemplateField | undefined);
+    constructor(type: $MessageTemplateFieldType, name: string, alias: string, path_raw: string, path_parsed: string, array: boolean, required: boolean, defaultValue: any, nullable: boolean, rules: $MessageTemplateRule[], meta: $MessageTemplateFieldMeta, children?: $MessageTemplateFields | undefined, or?: $MessageTemplateField | undefined);
 }
 export type $MessageTemplateFields = {
     [x: string]: $MessageTemplateField;

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

@@ -6,11 +6,12 @@ exports.$MessageTemplate = exports.$MessageTemplateField = void 0;
  * @subcategory Entity
  * */
 class $MessageTemplateField {
-    constructor(type, name, alias, path, array, required, defaultValue, nullable, rules, meta, children, or) {
+    constructor(type, name, alias, path_raw, path_parsed, array, required, defaultValue, nullable, rules, meta, children, or) {
         this.type = type;
         this.name = name;
         this.alias = alias;
-        this.path = path;
+        this.path_raw = path_raw;
+        this.path_parsed = path_parsed;
         this.array = array;
         this.required = required;
         this.defaultValue = defaultValue;

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

@@ -24,6 +24,11 @@ export declare class MessageTemplateFieldFactory<Space extends $Space, Module ex
     }, {
         '': any;
     }, {}, [never, never], [never, never]>;
+    ts<T = any>(): MessageTemplateFieldBuilder<Module, Message, {
+        '': T;
+    }, {
+        '': T;
+    }, {}, [never, never], [never, never]>;
     get boolean(): MessageTemplateFieldBuilder<Module, Message, {
         '': boolean;
     }, {
@@ -231,8 +236,8 @@ Nullable extends [null | never, null | never] = [never, never]> {
     rule(rule: MessageTemplateRuleDef<DefinedOutput[keyof DefinedOutput], 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;
+    static build(builder: AnyMessageTemplateFieldBuilder, name: string, tree: ModuleTree, module: $Module, basePathRaw: string, basePathParsed: string): $MessageTemplateField;
+    static buildChildren(fields: MessageTemplateFieldBuilders, tree: ModuleTree, module: $Module, basePathRaw?: string, basePathParsed?: string): $MessageTemplateFields;
 }
 export type MessageTemplateFieldBuilders = {
     [x: string]: AnyMessageTemplateFieldBuilder;

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

@@ -19,6 +19,9 @@ class MessageTemplateFieldFactory {
     get any() {
         return new MessageTemplateFieldBuilder('unknown', {}, this.alias);
     }
+    ts() {
+        return new MessageTemplateFieldBuilder('unknown', {}, this.alias);
+    }
     get boolean() {
         return new MessageTemplateFieldBuilder('boolean', {}, this.alias);
     }
@@ -154,21 +157,23 @@ class MessageTemplateFieldBuilder {
         return this;
     }
     // Build
-    static build(builder, name, tree, module, basePath) {
+    static build(builder, name, tree, module, basePathRaw, basePathParsed) {
         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 ? '*.' : '')
+            ? this.build(builder._or, name, tree, module, basePathRaw, basePathParsed)
             : undefined;
+        const pathParsed = basePathParsed + name;
+        const pathRaw = basePathParsed + (builder.type === 'id'
+            ? builder.array ? `${name.slice(0, -1)}_ids` : `${name}_id`
+            : name);
+        const childrenBasePathRaw = pathRaw + (builder._array ? '#.' : '');
+        const childrenBasePathParsed = pathParsed + (builder._array ? '#.' : '');
         if (builder.value.id) {
             const bucket = tree.getSchema(builder.value.id.bucket);
             builder.value.id.type = bucket.model.fields.id.type;
         }
-        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);
+        return new message_template_schema_1.$MessageTemplateField(builder.type, name, builder.alias || name, pathRaw, pathParsed, builder._array, builder._required, builder._defaultValue, builder._nullable, builder._rules, builder.value, builder.children ? MessageTemplateFieldBuilder.buildChildren(builder.children, tree, module, childrenBasePathRaw, childrenBasePathParsed) : undefined, or);
     }
-    static buildChildren(fields, tree, module, basePath = '') {
+    static buildChildren(fields, tree, module, basePathRaw = '', basePathParsed = '') {
         const schema = {};
         for (const c in fields) {
             const child = fields[c];
@@ -194,13 +199,13 @@ class MessageTemplateFieldBuilder {
                 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] = MessageTemplateFieldBuilder.build(builder, c, tree, module, basePathRaw, basePathParsed);
                 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);
+            schema[param] = MessageTemplateFieldBuilder.build(child, c, tree, module, basePathRaw, basePathParsed);
         }
         return schema;
     }

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

@@ -1,3 +1,7 @@
-import { $MessageTemplateField, $MessageTemplateFields } from './message_template.schema';
+import { $MessageTemplateField } 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>>;
+export declare function MessageTemplateFieldParser(raw: Record<string, any>, trx: AnyTrxNode, field: $MessageTemplateField, value: any): Promise<any>;
+/**
+ * Empty values: `{}`, `[]`, `''`, `null`, `undefined`
+ */
+export declare function isEmpty(value: any): boolean;