nesoi 3.0.20 → 3.0.21

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

@@ -36,7 +36,7 @@ function convertToView(model, name, fields = model.fields, path) {
  * */
 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, [], {
+        return new message_template_schema_1.$MessageTemplateField(field.type, field.name, field.alias, 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

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

@@ -21,8 +21,8 @@ class MessageBuilder {
         return this;
     }
     template($) {
-        const fieldBuilder = new message_template_field_builder_1.MessageTemplateFieldFactory(this.module);
-        const fields = $(fieldBuilder);
+        const factory = new message_template_field_builder_1.MessageTemplateFieldFactory(this.module);
+        const fields = $(factory);
         this._template.fields(fields);
         return this;
     }

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

@@ -11,6 +11,5 @@ export declare class MessageParser<$ extends $Message> {
     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;
 }
 export type AnyMessageParser = MessageParser<$Message>;

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

@@ -28,78 +28,11 @@ class MessageParser {
         }
         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 applyFieldRules = async (field, parent, value, path) => {
-            // Apply rules to the field
-            // If field is an array, the value passed to the rule is the array itself
-            for (const r in field.rules) {
-                const rule = field.rules[r];
-                const res = await rule({ field, value, path: path.join('.'), msg: parsed });
-                if (typeof res === 'object') {
-                    parent[path.at(-1)] = res.set;
-                }
-                else if (res !== true) {
-                    throw error_1.NesoiError.Message.RuleFailed({ rule, error: res });
-                }
-            }
-            if (!value)
-                return;
-            if (field.type === 'obj') {
-                if (field.array) {
-                    for (let i = 0; i < value?.length; i++) {
-                        await applyRules(field.children, value[i] || {}, [...path, i.toString()]);
-                    }
-                }
-                else {
-                    await applyRules(field.children, value || {}, path);
-                }
-            }
-            else if (field.type === 'dict') {
-                if (field.array) {
-                    for (let i = 0; i < value?.length; i++) {
-                        for (const k in value[i]) {
-                            await applyFieldRules(field.children.__dict, value[i], value[i][k], [...path, i.toString(), k]);
-                        }
-                    }
-                }
-                else {
-                    for (const k in value) {
-                        await applyFieldRules(field.children.__dict, value, value[k], [...path, k]);
-                    }
-                }
-            }
-        };
-        const applyRules = async (fields, parent, path = []) => {
-            for (const f in fields) {
-                const field = fields[f];
-                const value = parent[field.name];
-                const _path = [...path, field.name];
-                await applyFieldRules(field, parent, value, _path);
-            }
-        };
         const fields = this.schema.template.fields;
-        const parsed = {};
-        for (const k in fields) {
-            const field = fields[k];
-            const key_raw = field.path_raw.split('.')[0];
-            const key_parsed = field.path_parsed.split('.')[0];
-            const value = raw[key_raw];
-            this.sanitize(value);
-            parsed[key_parsed] = await (0, message_template_parser_1.MessageTemplateFieldParser)(raw, trx, field, value);
-        }
-        await applyRules(this.schema.template.fields, parsed);
+        const parsed = await (0, message_template_parser_1.MessageTemplateFieldParser)(trx, 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.'
-            });
-        }
-    }
 }
 exports.MessageParser = MessageParser;

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

@@ -6,6 +6,7 @@ export type $MessageTemplateRule = (def: {
     path: string;
     value: any;
     msg: $Message['#raw'];
+    inject: Record<string, any>;
 }) => {
     set: any;
 } | true | string | Promise<{
@@ -46,6 +47,10 @@ export declare class $MessageTemplateField {
     name: string;
     /** A human name for the field */
     alias: string;
+    /** A human name for the field union, assigned before the type.
+     * This is only relevant when using .obj.or, to allow for different
+     * aliases for the union and the root object */
+    preAlias: string;
     /** The absolute path for reading the field value on the raw object */
     path_raw: string;
     /** The absolute path for writing the field value on the parsed object */
@@ -55,6 +60,7 @@ export declare class $MessageTemplateField {
     defaultValue: any;
     nullable: boolean;
     rules: $MessageTemplateRule[];
+    arrayRules: $MessageTemplateRule[];
     meta: $MessageTemplateFieldMeta;
     children?: $MessageTemplateFields | undefined;
     or?: $MessageTemplateField | undefined;
@@ -71,10 +77,14 @@ export declare class $MessageTemplateField {
     name: string, 
     /** A human name for the field */
     alias: string, 
+    /** A human name for the field union, assigned before the type.
+     * This is only relevant when using .obj.or, to allow for different
+     * aliases for the union and the root object */
+    preAlias: string, 
     /** The absolute path for reading the field value on the raw object */
     path_raw: string, 
     /** The absolute path for writing the field value on the parsed object */
-    path_parsed: string, array: boolean, required: boolean, defaultValue: any, nullable: boolean, rules: $MessageTemplateRule[], meta: $MessageTemplateFieldMeta, children?: $MessageTemplateFields | undefined, or?: $MessageTemplateField | undefined);
+    path_parsed: string, array: boolean, required: boolean, defaultValue: any, nullable: boolean, rules: $MessageTemplateRule[], arrayRules: $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

@@ -16,13 +16,18 @@ class $MessageTemplateField {
     name, 
     /** A human name for the field */
     alias, 
+    /** A human name for the field union, assigned before the type.
+     * This is only relevant when using .obj.or, to allow for different
+     * aliases for the union and the root object */
+    preAlias, 
     /** The absolute path for reading the field value on the raw object */
     path_raw, 
     /** The absolute path for writing the field value on the parsed object */
-    path_parsed, array, required, defaultValue, nullable, rules, meta, children, or) {
+    path_parsed, array, required, defaultValue, nullable, rules, arrayRules, meta, children, or) {
         this.type = type;
         this.name = name;
         this.alias = alias;
+        this.preAlias = preAlias;
         this.path_raw = path_raw;
         this.path_parsed = path_parsed;
         this.array = array;
@@ -30,6 +35,7 @@ class $MessageTemplateField {
         this.defaultValue = defaultValue;
         this.nullable = nullable;
         this.rules = rules;
+        this.arrayRules = arrayRules;
         this.meta = meta;
         this.children = children;
         this.or = or;

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

@@ -18,6 +18,13 @@ export declare class MessageTemplateFieldFactory<Space extends $Space, Module ex
     private module;
     private alias?;
     constructor(module: string);
+    /**
+     * Specifies an alias for the field.
+     * - If this field is a union (.or), this alias is used when
+     * referring to the union and it's first option.
+     * - You can specify a different alias for the first options
+     * by also using the .as() after the type
+    */
     as(alias: string): Omit<typeof this, "as">;
     get any(): MessageTemplateFieldBuilder<Module, Message, {
         '': any;
@@ -227,7 +234,9 @@ Nullable extends [null | never, null | never] = [never, never]> {
     private _defaultValue?;
     private _nullable;
     private _rules;
+    private _arrayRules;
     private _or?;
+    private preAlias?;
     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>;
@@ -245,8 +254,10 @@ export type MessageTemplateFieldBuilders = {
 export type AnyMessageTemplateFieldBuilder = MessageTemplateFieldBuilder<any, any, any, any, any>;
 export type MessageTemplateRuleDef<I, Msg> = (def: {
     field: $MessageTemplateField;
+    path: string;
     value: I;
     msg: Msg;
+    inject: Record<string, any>;
 }) => {
     set: I;
 } | true | string | Promise<{

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

@@ -12,9 +12,17 @@ class MessageTemplateFieldFactory {
     constructor(module) {
         this.module = module;
     }
+    /**
+     * Specifies an alias for the field.
+     * - If this field is a union (.or), this alias is used when
+     * referring to the union and it's first option.
+     * - You can specify a different alias for the first options
+     * by also using the .as() after the type
+    */
     as(alias) {
-        this.alias = alias;
-        return this;
+        const chain = new MessageTemplateFieldFactory(this.module);
+        chain.alias = alias;
+        return chain;
     }
     get any() {
         return new MessageTemplateFieldBuilder('unknown', {}, this.alias);
@@ -106,6 +114,8 @@ class MessageTemplateFieldBuilder {
         this._defaultValue = undefined;
         this._nullable = true;
         this._rules = [];
+        this._arrayRules = [];
+        this.preAlias = alias;
     }
     as(alias) {
         this.alias = alias;
@@ -136,7 +146,12 @@ class MessageTemplateFieldBuilder {
         return this;
     }
     rule(rule) {
-        this._rules.push(rule);
+        if (this._array) {
+            this._arrayRules.push(rule);
+        }
+        else {
+            this._rules.push(rule);
+        }
         return this;
     }
     get array() {
@@ -149,11 +164,12 @@ class MessageTemplateFieldBuilder {
     }
     or(def) {
         this._or = def;
+        this._or.preAlias = this.preAlias;
         this._or._array = this._array;
         this._or._defaultValue = this._defaultValue;
         this._or._nullable = this._nullable;
         this._or._required = this._required;
-        this._or._rules = this._rules;
+        this._or._arrayRules = this._arrayRules;
         return this;
     }
     // Build
@@ -171,7 +187,7 @@ class MessageTemplateFieldBuilder {
             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, 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);
+        return new message_template_schema_1.$MessageTemplateField(builder.type, name, builder.alias || name, builder.preAlias || name, pathRaw, pathParsed, builder._array, builder._required, builder._defaultValue, builder._nullable, builder._rules, builder._arrayRules, builder.value, builder.children ? MessageTemplateFieldBuilder.buildChildren(builder.children, tree, module, childrenBasePathRaw, childrenBasePathParsed) : undefined, or);
     }
     static buildChildren(fields, tree, module, basePathRaw = '', basePathParsed = '') {
         const schema = {};

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

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

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

@@ -4,19 +4,34 @@ exports.MessageTemplateFieldParser = MessageTemplateFieldParser;
 exports.isEmpty = isEmpty;
 const parse_1 = require("../../../../engine/util/parse");
 const error_1 = require("../../../../engine/data/error");
-async function MessageTemplateFieldParser(raw, trx, field, value) {
-    return parseFieldValue(trx, field, raw, value, 0);
+// TODO: OPTIMIZATION
+// Parse everything that's static first, then move on to
+// parsing ids etc.
+async function MessageTemplateFieldParser(trx, fields, raw) {
+    const parsed = {};
+    const inject = {};
+    for (const k in fields) {
+        const field = fields[k];
+        const key_raw = field.path_raw.split('.')[0];
+        const key_parsed = field.path_parsed.split('.')[0];
+        const value = raw[key_raw];
+        parsed[key_parsed] = await parseFieldValue(trx, field, [field.name], raw, value, inject);
+    }
+    Object.assign(parsed, inject);
+    return parsed;
 }
-// Attempt to parse a field value
-// - If field is an array, this method is run for each value, sequentially
-// - If not, it's run for the original value, once
-//
-// - This method stacks with the .or options
-//
-async function parseFieldValue(trx, field, raw, value, path_idx) {
+/**
+ * [Parser Step 1]
+ *
+ * - Check for empty fields ({}, [], '', null, undefined)
+ * - If it's array, run step 2 for each value (with this field and path+i)
+ *  - If not, run step 2 for the original value (with this field and path)
+ */
+async function parseFieldValue(trx, field, path, raw, value, inject) {
+    sanitize(field, path, value);
     if (isEmpty(value)) {
         if (field.required) {
-            throw error_1.NesoiError.Message.FieldIsRequired({ field: field.alias, path: field.path_raw, value });
+            throw error_1.NesoiError.Message.FieldIsRequired({ alias: field.alias, path: path.join('.'), value });
         }
         else if (field.defaultValue !== undefined) {
             return field.defaultValue;
@@ -25,95 +40,132 @@ async function parseFieldValue(trx, field, raw, value, path_idx) {
             return undefined;
         }
     }
+    let output;
     if (field.array) {
         if (!Array.isArray(value)) {
-            throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path: field.path_raw, value, type: 'list' });
-        }
-        if (field.required && !value.length) {
-            throw error_1.NesoiError.Message.FieldIsRequired({ field: field.alias, path: field.path_raw, value });
+            throw error_1.NesoiError.Message.InvalidFieldType({ alias: field.alias, path: path.join('.'), value, type: 'list' });
         }
-        const parsedValue = [];
+        output = [];
         for (let i = 0; i < value.length; i++) {
             const v = value[i];
-            const parsed = await _attemptUnion(trx, field, raw, v, path_idx + 1);
-            parsedValue.push(parsed);
+            const parsedValue = await _attemptUnion(trx, field, [...path, i.toString()], raw, v, inject);
+            output.push(parsedValue);
         }
-        return parsedValue;
+        output = await applyFieldRules('array', field, path, raw, output, inject);
     }
-    return _attemptUnion(trx, field, raw, value, path_idx);
+    else {
+        output = await _attemptUnion(trx, field, path, raw, value, inject);
+    }
+    return output;
 }
-async function _attemptUnion(trx, field, raw, value, path_idx, unionErrors = []) {
+/**
+ * [Parser Step 2]
+ *
+ * - Attempt to run parse method (step 3) for field.
+ *  - If it fails, attempt other union options (step 2) (if available), with same path
+ * - If it works, apply field rules.
+ */
+async function _attemptUnion(trx, field, path, raw, value, inject, unionErrors = []) {
+    let output = undefined;
     try {
-        return await _runParseMethod(trx, field, raw, value, path_idx);
+        output = await _runParseMethod(trx, field, path, raw, value, inject);
     }
     catch (e) {
+        const ue = [
+            ...unionErrors,
+            {
+                option: field.alias,
+                name: e.name,
+                status: e.status,
+                message: e.message,
+                data: e.data,
+            }
+        ];
         // If failed and there's a second option, atempt it
         if (field.or) {
-            return await _attemptUnion(trx, field.or, raw, value, path_idx, [...unionErrors, e]);
+            return await _attemptUnion(trx, field.or, path, raw, value, inject, ue);
         }
         // If this error was not the first attempt, and we have no other option
         // we throw a specific error
         // This avoid confusion for the client when parsing unions
         if (unionErrors.length) {
-            throw error_1.NesoiError.Message.ValueDoesntMatchUnion({ field: field.alias, path: field.path_raw, value, unionErrors: [...unionErrors, e] });
+            throw error_1.NesoiError.Message.ValueDoesntMatchUnion({ alias: field.preAlias, path: path.join('.'), value, unionErrors: ue });
         }
         throw e;
     }
+    output = await applyFieldRules('item', field, path, raw, output, inject);
+    return output;
 }
-async function _runParseMethod(trx, field, raw, value, path_idx) {
+/**
+ * [Parser Step 3]
+ *
+ * - Run a specific parsing method based on the field type
+ */
+async function _runParseMethod(trx, field, path, raw, value, inject) {
     switch (field.type) {
         case 'obj':
         case 'dict':
-            return await parseParentField(trx, field, raw, value, path_idx);
+            return await parseParentField(trx, field, path, raw, value, inject);
         case 'unknown':
             return value;
         case 'boolean':
-            return (0, parse_1.parseBoolean)(field, value);
+            return (0, parse_1.parseBoolean)(field, path, value);
         case 'date':
-            return (0, parse_1.parseDate)(field, value);
+            return (0, parse_1.parseDate)(field, path, value);
         case 'datetime':
-            return (0, parse_1.parseDatetime)(field, value);
+            return (0, parse_1.parseDatetime)(field, path, value);
         case 'duration':
-            return (0, parse_1.parseDuration)(field, value);
+            return (0, parse_1.parseDuration)(field, path, value);
         case 'decimal':
-            return (0, parse_1.parseDecimal)(field, value);
+            return (0, parse_1.parseDecimal)(field, path, value);
         case 'enum':
-            return (0, parse_1.parseEnum)(raw, field, value, field.meta.enum.options, trx);
+            return (0, parse_1.parseEnum)(raw, field, path, value, field.meta.enum.options, trx);
         case 'file':
-            return (0, parse_1.parseFile)(field, value, field.meta.file);
+            return (0, parse_1.parseFile)(field, path, value, field.meta.file);
         case 'float':
-            return (0, parse_1.parseFloat_)(field, value);
+            return (0, parse_1.parseFloat_)(field, path, value);
         case 'int':
-            return (0, parse_1.parseInt_)(field, value);
+            return (0, parse_1.parseInt_)(field, path, value);
         case 'string':
-            return (0, parse_1.parseString)(field, value);
+            return (0, parse_1.parseString)(field, path, value);
         case 'string_or_number':
-            return (0, parse_1.parseStringOrNumber)(field, value);
+            return (0, parse_1.parseStringOrNumber)(field, path, value);
         case 'id':
-            return await parseIdField(trx, field, value);
+            return await parseIdField(trx, field, path, value);
     }
     throw error_1.NesoiError.Builder.Message.UnknownTemplateFieldType(field.type);
 }
-async function parseParentField(trx, field, raw, value, path_idx) {
+/**
+ * [Parser Step 3-b]: 'obj' or 'dict'
+ *
+ * - The parser methods only return a tuple of field and value, to be parsed again by (step 1)
+ * - When calling step 1, the child property name is appended to the path
+ */
+async function parseParentField(trx, field, path, raw, value, inject) {
     let children;
     if (field.type === 'obj') {
-        children = (0, parse_1.parseObj)(field, value, path_idx);
+        children = (0, parse_1.parseObj)(field, path, value);
     }
     else {
-        children = (0, parse_1.parseDict)(field, value);
+        children = (0, parse_1.parseDict)(field, path, value);
     }
-    const parsed = {};
+    const parsedParent = {};
     for (const key in children) {
         const child = children[key];
-        parsed[key] = await parseFieldValue(trx, child.field, raw, child.value, path_idx + 1);
+        parsedParent[key] = await parseFieldValue(trx, child.field, [...path, key], raw, child.value, inject);
     }
-    return parsed;
+    return parsedParent;
 }
-async function parseIdField(trx, field, value) {
+/**
+ * [Parser Step 3-b]: 'id'
+ *
+ * - Gathers the data for parsing a id
+ */
+async function parseIdField(trx, field, path, value) {
     const bucket = field.meta.id.bucket;
     const type = field.meta.id.type;
     const view = field.meta.id.view;
-    const parsed = await (0, parse_1.parseId)(field, value, trx, bucket.refName, type, view);
+    const parsed = await (0, parse_1.parseId)(field, path, value, trx, bucket.refName, type, view);
     if (field.array) {
         return parsed.map((p) => p.obj);
     }
@@ -121,6 +173,13 @@ async function parseIdField(trx, field, value) {
         return parsed.obj;
     }
 }
+function sanitize(field, path, value) {
+    if (typeof value === 'function') {
+        throw error_1.NesoiError.Message.UnsanitaryValue({
+            alias: field.alias, path: path.join('.'), details: 'Functions not allowed as message inputs.'
+        });
+    }
+}
 /**
  * Empty values: `{}`, `[]`, `''`, `null`, `undefined`
  */
@@ -139,3 +198,25 @@ function isEmpty(value) {
     }
     return false;
 }
+/**
+ * Rules
+ */
+async function applyFieldRules(mode, field, path, raw, value, inject) {
+    let output = value;
+    // If mode is item, the value received is not an array
+    //  - This comes from a .rule *before* .array
+    // If mode is array, the value received is an array
+    //  - This comes from a .rule *after* .array
+    const rules = mode === 'item' ? field.rules : field.arrayRules;
+    for (const r in rules) {
+        const rule = rules[r];
+        const res = await rule({ field, value, path: path.join('.'), msg: raw, inject });
+        if (typeof res === 'object') {
+            output = res.set;
+        }
+        else if (res !== true) {
+            throw error_1.NesoiError.Message.RuleFailed({ alias: field.alias, path: path.join('.'), rule, error: res });
+        }
+    }
+    return output;
+}

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

@@ -169,53 +169,54 @@ export declare namespace NesoiError {
             module: string;
         }): BaseError;
         function InvalidEnumScope($: {
+            alias: string;
             path: string;
-            name: string;
-            alias?: string;
             value: any;
             fieldpath: string;
         }): BaseError;
         function InvalidFieldEnumValue($: {
-            field: string;
+            alias: string;
             path: string;
             value: any;
             type: string;
             options: string[];
         }): BaseError;
         function InvalidFieldType($: {
-            field: string;
+            alias: string;
             path: string;
             value: any;
             type: string;
         }): BaseError;
         function ValueDoesntMatchUnion($: {
-            field: string;
+            alias: string;
             path: string;
             value: any;
-            unionErrors: string[];
+            unionErrors: Record<string, any>[];
         }): BaseError;
         function UnsanitaryValue($: {
+            alias: string;
+            path: string;
             details: string;
         }): BaseError;
         function FieldIsRequired($: {
-            field: string;
+            alias: string;
             path: string;
             value: any;
         }): BaseError;
         function RuleFailed($: {
+            alias: string;
+            path: string;
             rule: $MessageTemplateRule;
             error: string;
         }): BaseError;
         function FileTooBig($: {
+            alias: string;
             path: string;
-            name: string;
-            alias?: string;
             maxsize: number;
         }): BaseError;
         function FileExtNotAllowed($: {
+            alias: string;
             path: string;
-            name: string;
-            alias?: string;
             options: string[];
         }): BaseError;
     }

package/lib/engine/data/error.js

@@ -302,19 +302,19 @@ var NesoiError;
         }
         Message.NotSupportedByModule = NotSupportedByModule;
         function InvalidEnumScope($) {
-            return new BaseError('Message.InvalidEnumScope', `${$.alias || $.name} is an enum with dynamic scope, and the path '${$.fieldpath}' of the message has an invalid value '${$.value}'`, Status.BAD_REQUEST, $);
+            return new BaseError('Message.InvalidEnumScope', `${$.alias} is an enum with dynamic scope, and the path '${$.fieldpath}' of the message has an invalid value '${$.value}'`, Status.BAD_REQUEST, $);
         }
         Message.InvalidEnumScope = InvalidEnumScope;
         function InvalidFieldEnumValue($) {
-            return new BaseError('Message.InvalidFieldEnumValue', `Message field '${$.field}' value '${$.value}' should be one of the following: ${$.options?.join(',')}`, Status.BAD_REQUEST, $);
+            return new BaseError('Message.InvalidFieldEnumValue', `Message field '${$.alias}' value '${$.value}' should be one of the following: ${$.options?.join(',')}`, Status.BAD_REQUEST, $);
         }
         Message.InvalidFieldEnumValue = InvalidFieldEnumValue;
         function InvalidFieldType($) {
-            return new BaseError('Message.InvalidFieldType', `Message field '${$.field}' value '${$.value}' is not of type '${$.type}'`, Status.BAD_REQUEST, $);
+            return new BaseError('Message.InvalidFieldType', `Message field '${$.alias}' value '${$.value}' is not of type '${$.type}'`, Status.BAD_REQUEST, $);
         }
         Message.InvalidFieldType = InvalidFieldType;
         function ValueDoesntMatchUnion($) {
-            return new BaseError('Message.ValueDoesntMatchUnion', `Message field '${$.field}' (${$.path}) value '${$.value}' doesn't match any of the union options'`, Status.BAD_REQUEST, $);
+            return new BaseError('Message.ValueDoesntMatchUnion', `Message field '${$.alias}' (${$.path}) value '${$.value}' doesn't match any of the union options'`, Status.BAD_REQUEST, $);
         }
         Message.ValueDoesntMatchUnion = ValueDoesntMatchUnion;
         function UnsanitaryValue($) {
@@ -322,7 +322,7 @@ var NesoiError;
         }
         Message.UnsanitaryValue = UnsanitaryValue;
         function FieldIsRequired($) {
-            return new BaseError('Message.FieldIsRequired', `Field ${$.field} (${$.path}) is required`, Status.BAD_REQUEST, $);
+            return new BaseError('Message.FieldIsRequired', `Field ${$.alias} (${$.path}) is required`, Status.BAD_REQUEST, $);
         }
         Message.FieldIsRequired = FieldIsRequired;
         function RuleFailed($) {
@@ -330,11 +330,11 @@ var NesoiError;
         }
         Message.RuleFailed = RuleFailed;
         function FileTooBig($) {
-            return new BaseError('Message.FileTooBig', `${$.alias || $.name} size exceeds max (${$.maxsize})`, Status.BAD_REQUEST, $);
+            return new BaseError('Message.FileTooBig', `${$.alias} size exceeds max (${$.maxsize})`, Status.BAD_REQUEST, $);
         }
         Message.FileTooBig = FileTooBig;
         function FileExtNotAllowed($) {
-            return new BaseError('Message.FileExtNotAllowed', `${$.alias || $.name} extension not allowed. Options: ${$.options}`, Status.BAD_REQUEST, $);
+            return new BaseError('Message.FileExtNotAllowed', `${$.alias} extension not allowed. Options: ${$.options}`, Status.BAD_REQUEST, $);
         }
         Message.FileExtNotAllowed = FileExtNotAllowed;
     })(Message = NesoiError.Message || (NesoiError.Message = {}));