nesoi 3.0.19 → 3.0.21

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

@@ -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,55 +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 parseFields = async (trx, fields, obj) => {
-            const parsedObj = {};
-            for (const k in fields) {
-                const field = fields[k];
-                parsedObj[k] = await parseField(trx, field, obj[k]);
-            }
-            return parsedObj;
-        };
-        const parseField = async (trx, field, value) => {
-            // 1. Sanitize input
-            this.sanitize(value);
-            // 2. Check for required fields
-            return (0, message_template_parser_1.MessageTemplateFieldParser)(raw, trx, field, value);
-        };
-        const applyRules = async (fields, parsed, parsedValue = parsed) => {
-            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 parsed = await parseFields(trx, this.schema.template.fields, raw);
-        await applyRules(this.schema.template.fields, parsed);
+        const fields = this.schema.template.fields;
+        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

@@ -3,8 +3,10 @@ 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'];
+    inject: Record<string, any>;
 }) => {
     set: any;
 } | true | string | Promise<{
@@ -36,23 +38,53 @@ 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;
+    /** 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[];
+    arrayRules: $MessageTemplateRule[];
     meta: $MessageTemplateFieldMeta;
     children?: $MessageTemplateFields | undefined;
     or?: $MessageTemplateField | undefined;
     '#raw': unknown;
     '#parsed': unknown;
     $t: string;
-    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);
+    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, 
+    /** 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[], 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

@@ -6,10 +6,28 @@ exports.$MessageTemplate = exports.$MessageTemplateField = void 0;
  * @subcategory Entity
  * */
 class $MessageTemplateField {
-    constructor(type, name, alias, path_raw, path_parsed, 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, 
+    /** 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, 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;
@@ -17,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
@@ -163,15 +179,15 @@ class MessageTemplateFieldBuilder {
             : undefined;
         const pathParsed = basePathParsed + name;
         const pathRaw = basePathParsed + (builder.type === 'id'
-            ? builder.array ? `${name.slice(0, -1)}_ids` : `${name}_id`
+            ? builder._array ? `${name}_ids` : `${name}_id`
             : name);
-        const childrenBasePathRaw = pathRaw + (builder._array ? '#.' : '');
-        const childrenBasePathParsed = pathParsed + (builder._array ? '#.' : '');
+        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, 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, field.path_raw, raw, value);
+// 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, path, raw, value) {
+/**
+ * [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, value });
+            throw error_1.NesoiError.Message.FieldIsRequired({ alias: field.alias, path: path.join('.'), value });
         }
         else if (field.defaultValue !== undefined) {
             return field.defaultValue;
@@ -25,46 +40,72 @@ async function parseFieldValue(trx, field, path, raw, value) {
             return undefined;
         }
     }
+    let output;
     if (field.array) {
         if (!Array.isArray(value)) {
-            throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path, value, type: 'list' });
-        }
-        if (field.required && !value.length) {
-            throw error_1.NesoiError.Message.FieldIsRequired({ field: field.alias, path, 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, `${path}.${i}`, raw, v);
-            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, path, raw, value);
+    else {
+        output = await _attemptUnion(trx, field, path, raw, value, inject);
+    }
+    return output;
 }
-async function _attemptUnion(trx, field, path, raw, value, 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, path, raw, value);
+        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, path, raw, value, [...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, 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, path, raw, value) {
+/**
+ * [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, path, raw, value);
+            return await parseParentField(trx, field, path, raw, value, inject);
         case 'unknown':
             return value;
         case 'boolean':
@@ -94,7 +135,13 @@ async function _runParseMethod(trx, field, path, raw, value) {
     }
     throw error_1.NesoiError.Builder.Message.UnknownTemplateFieldType(field.type);
 }
-async function parseParentField(trx, field, path, raw, value) {
+/**
+ * [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, path, value);
@@ -102,13 +149,18 @@ async function parseParentField(trx, field, path, raw, value) {
     else {
         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, `${path}.${key}`, raw, child.value);
+        parsedParent[key] = await parseFieldValue(trx, child.field, [...path, key], raw, child.value, inject);
     }
-    return parsed;
+    return parsedParent;
 }
+/**
+ * [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;
@@ -121,6 +173,13 @@ async function parseIdField(trx, field, path, 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;
+}