nesoi 3.0.18 → 3.0.20

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/blocks/block.builder.d.ts

@@ -1,6 +1,6 @@
 import { $Module, $Space } from "../../schema";
 import { $BlockOutput, $BlockType } from './block.schema';
-import { MultiMessageTemplateDef } from "../entities/message/template/message_template.builder";
+import { MessageTemplateDef, MultiMessageTemplateDef } from "../entities/message/template/message_template.builder";
 import { $Dependency, BuilderNode } from "../../engine/dependency";
 /**
  * @category Builders
@@ -19,11 +19,20 @@ export declare abstract class BlockBuilder<Space extends $Space, Module extends
     /** Block "human" name */
     as(alias: string): this;
     /**
+     * Inline messages. This messages is exposed to the module,
+     * with a name prefixed by the block name.
+     * @param def A method which takes a field factory as input and outputs a template builder
+     * @returns The Builder, for call-chaining
+     */
+    protected message<Name extends string, Def extends MessageTemplateDef<Space, Module, Name>>(name: Name, def: Def): unknown;
+    /**
+     * @deprecated
      * Inline messages. These messages are exposed to the module,
      * with a name prefixed by the block name.
      * @param def A method which takes a field factory as input and outputs a template builder
      * @returns The Builder, for call-chaining
      */
+    /** @deprecated Use `.message` instead. Will be removed on 3.1 */
     protected messages<Def extends MultiMessageTemplateDef<Space, Module>>(def: Def): unknown;
     authn(...providers: string[]): unknown;
     protected _input(...names: string[]): unknown;

package/lib/elements/blocks/block.builder.js

@@ -26,11 +26,37 @@ class BlockBuilder {
     }
     // Inline Messages
     /**
+     * Inline messages. This messages is exposed to the module,
+     * with a name prefixed by the block name.
+     * @param def A method which takes a field factory as input and outputs a template builder
+     * @returns The Builder, for call-chaining
+     */
+    message(name, def) {
+        const msgName = `${this.name}${name.length ? ('.' + name) : ''}`;
+        this._inputMsgs.push(new dependency_1.$Dependency(this.module, 'message', msgName));
+        const builder = new message_builder_1.MessageBuilder(this.module, msgName)
+            .template(def);
+        this._inlineNodes.push(new dependency_1.BuilderNode({
+            module: this.module,
+            type: 'message',
+            name: msgName,
+            builder,
+            isInline: true,
+            filepath: [], // This is added later by Treeshake.blockInlineNodes()
+            dependencies: [] // This is added later by Treeshake.*()
+        }));
+        const dep = new dependency_1.$Dependency(this.module, 'message', msgName);
+        this._inputMsgs.push(dep);
+        return this;
+    }
+    /**
+     * @deprecated
      * Inline messages. These messages are exposed to the module,
      * with a name prefixed by the block name.
      * @param def A method which takes a field factory as input and outputs a template builder
      * @returns The Builder, for call-chaining
      */
+    /** @deprecated Use `.message` instead. Will be removed on 3.1 */
     messages(def) {
         const factory = new message_template_field_builder_1.MessageTemplateFieldFactory(this.module);
         const schema = def(factory);

package/lib/elements/blocks/job/job.builder.d.ts

@@ -1,7 +1,7 @@
 import { $Module, $Space, ScopedMessage, ScopedMessageName } from "../../../schema";
 import { $Job, $JobAssert, $JobMethod } from './job.schema';
 import { BlockBuilder } from '../block.builder';
-import { MultiMessageTemplateDef } from "../../entities/message/template/message_template.builder";
+import { MessageTemplateDef, MultiMessageTemplateDef } from "../../entities/message/template/message_template.builder";
 import { Overlay } from "../../../engine/util/type";
 import { $MessageInfer } from "../../entities/message/message.infer";
 import { TrxNode } from "../../../engine/transaction/trx_node";
@@ -33,6 +33,12 @@ export declare class JobBuilder<Space extends $Space, Module extends $Module, Jo
         from: keyof Machine["states"] & string;
         to: keyof Machine["states"] & string;
     }>;
+    message<Name extends string, Def extends MessageTemplateDef<Space, Module, Name>, FullName extends string = `${Job['name']}${Name extends '' ? '' : '.'}${Name & string}`, Msg extends $Message = $MessageInfer<FullName, ($: any) => ReturnType<Def>>>(name: Name, def: Def): JobBuilder<Space, Overlay<Module, {
+        messages: Overlay<Module["messages"], { [K in FullName]: Msg; }>;
+    }>, Overlay<Job, {
+        "#input": Msg;
+    }>, Ctx>;
+    /** @deprecated Use `.message` instead. Will be removed on 3.1 */
     messages<Def extends MultiMessageTemplateDef<Space, Module>>(def: Def): JobBuilder<Space, Overlay<Module, {
         messages: Overlay<Module["messages"], { [K in keyof ReturnType<Def> as `${Job["name"]}${K extends "" ? "" : "."}${K & string}`]: $MessageInfer<`${Job["name"]}${K extends "" ? "" : "."}${K & string}`, ($: any) => ReturnType<Def>[K], ReturnType<Def>[K], import("../../entities/message/message.infer").$MessageInputInfer<ReturnType<Def>[K], ReturnType<Def>[K] extends infer T ? { [K_1 in keyof T]: ReturnType<Def>[K][K_1] extends import("../../entities/message/template/message_template_field.builder").MessageTemplateFieldBuilder<any, any, infer I, any, any, infer Opt extends [undefined, undefined], infer Nul extends [null, null]> ? {
             path: `${K_1 & string}${keyof I & string}`;

package/lib/elements/blocks/job/job.builder.js

@@ -31,6 +31,10 @@ class JobBuilder extends block_builder_1.BlockBuilder {
         return this;
     }
     /* [Job] */
+    message(name, def) {
+        return super.message(name, def);
+    }
+    /** @deprecated Use `.message` instead. Will be removed on 3.1 */
     messages(def) {
         return super.messages(def);
     }

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

@@ -33,80 +33,64 @@ class MessageParser {
     // 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'
-                    ? field.array ? `${k.slice(0, -1)}_ids` : `${k}_id`
-                    : k;
-                const parsedField = await parseField(trx, field, obj[keyWithSuffix]);
-                for (const suffix in parsedField) {
-                    parsedObj[field.name + suffix] = parsedField[suffix];
+        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;
                 }
-            }
-            return parsedObj;
-        };
-        const parseField = async (trx, field, value) => {
-            // 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 (res !== true) {
+                    throw error_1.NesoiError.Message.RuleFailed({ rule, error: res });
                 }
-                else if (field.defaultValue !== undefined) {
-                    parsedValue = { '': field.defaultValue };
+            }
+            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 {
-                    parsedValue = { '': undefined };
+                    await applyRules(field.children, value || {}, path);
                 }
             }
-            else {
+            else if (field.type === 'dict') {
                 if (field.array) {
-                    if (!Array.isArray(value)) {
-                        throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value, type: 'list' });
+                    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]);
+                        }
                     }
                 }
-                // 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);
+                else {
+                    for (const k in value) {
+                        await applyFieldRules(field.children.__dict, value, value[k], [...path, k]);
                     }
-                    e.__msg_deep_error = true;
-                    throw e;
                 }
             }
-            return parsedValue;
         };
-        const applyRules = async (fields, parsed, parsedValue = parsed) => {
+        const applyRules = async (fields, parent, path = []) => {
             for (const f in fields) {
                 const field = fields[f];
-                for (const r in field.rules) {
-                    const rule = field.rules[r];
-                    const value = parsedValue?.[field.name];
-                    const res = await rule({ field, value, msg: parsed });
-                    if (typeof res === 'object') {
-                        parsedValue ?? (parsedValue = {});
-                        parsedValue[field.name] = res.set;
-                    }
-                    else if (res !== true) {
-                        throw error_1.NesoiError.Message.RuleFailed({ rule, error: res });
-                    }
-                }
-                if (field.children) {
-                    await applyRules(field.children, parsed, parsedValue?.[field.name]);
-                }
+                const value = parent[field.name];
+                const _path = [...path, field.name];
+                await applyFieldRules(field, parent, value, _path);
             }
         };
-        const parsed = await parseFields(trx, this.schema.template.fields, raw);
+        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);
         return message_1.Message.new(this.schema.name, parsed, sigKey);
     }
@@ -117,23 +101,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

@@ -3,6 +3,7 @@ import { $BucketModelFieldType } from "../../bucket/model/bucket_model.schema";
 import { $Dependency } from "../../../../engine/dependency";
 export type $MessageTemplateRule = (def: {
     field: $MessageTemplateField;
+    path: string;
     value: any;
     msg: $Message['#raw'];
 }) => {
@@ -36,10 +37,19 @@ export type $MessageTemplateFieldType = $BucketModelFieldType | 'string_or_numbe
  * @subcategory Entity
  * */
 export declare class $MessageTemplateField {
+    /** A string representing the type of data carried by the field */
     type: $MessageTemplateFieldType;
+    /**
+     * - A machine name for the field, unique inside it's parent (either another field or a message).
+     * - Matches the relative path for writing the field value on the parent parsed object (key_parsed).
+     */
     name: string;
+    /** A human name for the field */
     alias: string;
-    path: 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;
@@ -51,7 +61,20 @@ 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(
+    /** A string representing the type of data carried by the field */
+    type: $MessageTemplateFieldType, 
+    /**
+     * - A machine name for the field, unique inside it's parent (either another field or a message).
+     * - Matches the relative path for writing the field value on the parent parsed object (key_parsed).
+     */
+    name: string, 
+    /** A human name for the field */
+    alias: 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);
 }
 export type $MessageTemplateFields = {
     [x: string]: $MessageTemplateField;

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

@@ -6,11 +6,25 @@ exports.$MessageTemplate = exports.$MessageTemplateField = void 0;
  * @subcategory Entity
  * */
 class $MessageTemplateField {
-    constructor(type, name, alias, path, array, required, defaultValue, nullable, rules, meta, children, or) {
+    constructor(
+    /** A string representing the type of data carried by the field */
+    type, 
+    /**
+     * - A machine name for the field, unique inside it's parent (either another field or a message).
+     * - Matches the relative path for writing the field value on the parent parsed object (key_parsed).
+     */
+    name, 
+    /** A human name for the field */
+    alias, 
+    /** 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) {
         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;