nesoi 3.0.21 → 3.1.0

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

@@ -14,10 +14,6 @@ class MessageTemplateFieldFactory {
     }
     /**
      * 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) {
         const chain = new MessageTemplateFieldFactory(this.module);
@@ -82,10 +78,15 @@ class MessageTemplateFieldFactory {
         return new MessageTemplateFieldBuilder('obj', {}, this.alias, children);
     }
     dict(item) {
-        item = item.optional;
         return new MessageTemplateFieldBuilder('dict', {}, this.alias, { __dict: item });
     }
-    msg(msg, extra) {
+    list(item) {
+        return new MessageTemplateFieldBuilder('list', {}, this.alias, { '#': item });
+    }
+    union(...children) {
+        return new MessageTemplateFieldBuilder('union', {}, this.alias, Object.fromEntries(children.map((c, i) => [i, c])));
+    }
+    msg(msg, extra = {}) {
         // Module and tag are updated on build
         const ref = new dependency_1.$Dependency(this.module, 'message', msg);
         return new MessageTemplateFieldBuilder('msg', { msg: ref }, this.alias, extra);
@@ -109,13 +110,10 @@ class MessageTemplateFieldBuilder {
         this.value = value;
         this.alias = alias;
         this.children = children;
-        this._array = false;
         this._required = true;
         this._defaultValue = undefined;
-        this._nullable = true;
+        this._nullable = false;
         this._rules = [];
-        this._arrayRules = [];
-        this.preAlias = alias;
     }
     as(alias) {
         this.alias = alias;
@@ -123,105 +121,91 @@ class MessageTemplateFieldBuilder {
     }
     get optional() {
         this._required = false;
-        if (this._or) {
-            // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-            this._or.optional;
-        }
         return this;
     }
     default(value) {
         this._required = false;
         this._defaultValue = value;
-        if (this._or) {
-            this._or.default(value);
-        }
         return this;
     }
     get nullable() {
         this._nullable = true;
-        if (this._or) {
-            // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-            this._or.nullable;
-        }
         return this;
     }
     rule(rule) {
-        if (this._array) {
-            this._arrayRules.push(rule);
-        }
-        else {
-            this._rules.push(rule);
-        }
-        return this;
-    }
-    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;
-        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._arrayRules = this._arrayRules;
+        this._rules.push(rule);
         return this;
     }
     // Build
     static build(builder, name, tree, module, basePathRaw, basePathParsed) {
-        const or = builder._or
-            ? this.build(builder._or, name, tree, module, basePathRaw, basePathParsed)
-            : undefined;
+        const pathRaw = basePathRaw + (builder.type === 'id' ? `${name}_id` : name);
         const pathParsed = basePathParsed + name;
-        const pathRaw = basePathParsed + (builder.type === 'id'
-            ? builder._array ? `${name}_ids` : `${name}_id`
-            : name);
-        const childrenBasePathRaw = pathRaw + (builder._array ? '.#.' : '.');
-        const childrenBasePathParsed = pathParsed + (builder._array ? '.#.' : '.');
-        if (builder.value.id) {
+        const childrenBasePathRaw = pathRaw + '.';
+        const childrenBasePathParsed = pathParsed + '.';
+        let type = builder.type;
+        let children;
+        if (builder.type === '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, 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);
+        // A .msg() parameter is an obj which takes fields from
+        // another message
+        else if (builder.type === 'msg') {
+            const dep = builder.value.msg;
+            if (dep.type !== 'message') {
+                throw error_1.NesoiError.Builder.Message.UnknownModuleMessage(dep.tag);
+            }
+            const $msg = tree.getSchema(dep);
+            if (!$msg) {
+                throw error_1.NesoiError.Builder.Message.UnknownModuleMessage(dep.tag);
+            }
+            if (dep.module !== module.name) {
+                if (!(dep.refName in module.externals.messages)) {
+                    throw error_1.NesoiError.Builder.Message.UnknownModuleMessage(dep.tag);
+                }
+            }
+            const injectFields = (target, fields) => {
+                for (const key in fields) {
+                    target[key] = message_template_schema_1.$MessageTemplateField.clone(fields[key]);
+                    target[key].pathRaw = childrenBasePathRaw + target[key].pathRaw;
+                    target[key].pathParsed = childrenBasePathParsed + target[key].pathParsed;
+                    if (fields[key].children) {
+                        target[key].children = {};
+                        injectFields(target[key].children, fields[key].children);
+                    }
+                }
+            };
+            type = 'obj';
+            children = {};
+            injectFields(children, $msg.template.fields);
+        }
+        else if (builder.type === 'list') {
+            children = MessageTemplateFieldBuilder.buildMany(builder.children, tree, module, childrenBasePathRaw, childrenBasePathParsed, '#', '#');
+        }
+        else if (builder.type === 'dict') {
+            children = MessageTemplateFieldBuilder.buildMany(builder.children, tree, module, childrenBasePathRaw, childrenBasePathParsed, '#', '#');
+        }
+        else if (builder.type === 'union') {
+            children = MessageTemplateFieldBuilder.buildMany(builder.children, tree, module, basePathRaw, basePathParsed, name, undefined);
+        }
+        // All other fields build their children directly
+        else if (builder.children) {
+            children = MessageTemplateFieldBuilder.buildMany(builder.children, tree, module, childrenBasePathRaw, childrenBasePathParsed);
+        }
+        return new message_template_schema_1.$MessageTemplateField(type, name, builder.alias || name, pathRaw, pathParsed, builder._required, builder._defaultValue, builder._nullable, builder._rules, builder.value, children);
     }
-    static buildChildren(fields, tree, module, basePathRaw = '', basePathParsed = '') {
+    static buildMany(fields, tree, module, basePathRaw = '', basePathParsed = '', name, key) {
         const schema = {};
         for (const c in fields) {
-            const child = fields[c];
-            // Extended fields inherit from other messages
-            if (child.__ext) {
-                const ext = tree.getSchema(child.__ext);
-                schema[c].children = Object.assign({}, ext.template.fields, schema[c].children || {});
-                continue;
-            }
-            const param = c;
-            // A .msg() parameter is an obj which takes fields from
-            // another message
-            if (child.type === 'msg') {
-                const name = child.value.msg.name;
-                const $msg = module.messages[name];
-                if (!$msg) {
-                    throw error_1.NesoiError.Builder.Message.UnknownModuleMessage(name);
-                }
-                const builder = new MessageTemplateFieldFactory(module.name).obj({});
-                builder.alias = child.alias;
-                builder._required = child._required;
-                builder._defaultValue = child._defaultValue;
-                builder._nullable = child._nullable;
-                builder._rules = child._rules.slice(0, -1);
-                builder.children = child.children;
-                schema[param] = MessageTemplateFieldBuilder.build(builder, c, tree, module, basePathRaw, basePathParsed);
-                schema[param].children = schema[param].children || {};
-                Object.assign(schema[param].children, $msg.template.fields);
+            if (c === '__ext')
                 continue;
-            }
-            // All other parameters are built directly
-            schema[param] = MessageTemplateFieldBuilder.build(child, c, tree, module, basePathRaw, basePathParsed);
+            const child = fields[c];
+            schema[key || c] = MessageTemplateFieldBuilder.build(child, name || c, tree, module, basePathRaw, basePathParsed);
+        }
+        // Extended field groups inherit from other messages
+        if ('__ext' in fields) {
+            const ext = tree.getSchema(fields.__ext);
+            Object.assign(schema, ext.template.fields);
         }
         return schema;
     }

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

@@ -12,8 +12,8 @@ async function MessageTemplateFieldParser(trx, fields, raw) {
     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 key_raw = field.pathRaw.split('.')[0];
+        const key_parsed = field.pathParsed.split('.')[0];
         const value = raw[key_raw];
         parsed[key_parsed] = await parseFieldValue(trx, field, [field.name], raw, value, inject);
     }
@@ -40,22 +40,8 @@ async function parseFieldValue(trx, field, path, raw, value, inject) {
             return undefined;
         }
     }
-    let output;
-    if (field.array) {
-        if (!Array.isArray(value)) {
-            throw error_1.NesoiError.Message.InvalidFieldType({ alias: field.alias, path: path.join('.'), value, type: 'list' });
-        }
-        output = [];
-        for (let i = 0; i < value.length; i++) {
-            const v = value[i];
-            const parsedValue = await _attemptUnion(trx, field, [...path, i.toString()], raw, v, inject);
-            output.push(parsedValue);
-        }
-        output = await applyFieldRules('array', field, path, raw, output, inject);
-    }
-    else {
-        output = await _attemptUnion(trx, field, path, raw, value, inject);
-    }
+    let output = await _attemptUnion(trx, field, path, raw, value, inject);
+    output = await applyFieldRules(field, path, raw, output, inject);
     return output;
 }
 /**
@@ -65,35 +51,31 @@ async function parseFieldValue(trx, field, path, raw, value, inject) {
  *  - 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 {
-        output = await _runParseMethod(trx, field, path, raw, value, inject);
+async function _attemptUnion(trx, field, path, raw, value, inject) {
+    if (field.type !== 'union') {
+        return _runParseMethod(trx, field, path, raw, value, inject);
     }
-    catch (e) {
-        const ue = [
-            ...unionErrors,
-            {
-                option: field.alias,
+    const unionErrors = [];
+    let output = undefined;
+    for (const k in field.children) {
+        const option = field.children[k];
+        try {
+            output = await _runParseMethod(trx, option, path, raw, value, inject);
+            break;
+        }
+        catch (e) {
+            unionErrors.push({
+                option: option.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, 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({ alias: field.preAlias, path: path.join('.'), value, unionErrors: ue });
-        }
-        throw e;
     }
-    output = await applyFieldRules('item', field, path, raw, output, inject);
+    if (unionErrors.length === Object.keys(field.children).length) {
+        throw error_1.NesoiError.Message.ValueDoesntMatchUnion({ alias: field.alias, path: path.join('.'), value, unionErrors });
+    }
     return output;
 }
 /**
@@ -105,7 +87,8 @@ async function _runParseMethod(trx, field, path, raw, value, inject) {
     switch (field.type) {
         case 'obj':
         case 'dict':
-            return await parseParentField(trx, field, path, raw, value, inject);
+        case 'list':
+            return parseParentField(trx, field, path, raw, value, inject);
         case 'unknown':
             return value;
         case 'boolean':
@@ -131,30 +114,41 @@ async function _runParseMethod(trx, field, path, raw, value, inject) {
         case 'string_or_number':
             return (0, parse_1.parseStringOrNumber)(field, path, value);
         case 'id':
-            return await parseIdField(trx, field, path, value);
+            return parseIdField(trx, field, path, value);
     }
     throw error_1.NesoiError.Builder.Message.UnknownTemplateFieldType(field.type);
 }
 /**
- * [Parser Step 3-b]: 'obj' or 'dict'
+ * [Parser Step 3-b]: 'obj' or 'dict' or 'list'
  *
  * - 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);
+    if (field.type === 'list') {
+        const children = (0, parse_1.parseList)(field, path, value);
+        const parsedParent = [];
+        for (const key in children) {
+            const child = children[key];
+            parsedParent.push(await parseFieldValue(trx, child.field, [...path, key], raw, child.value, inject));
+        }
+        return parsedParent;
     }
     else {
-        children = (0, parse_1.parseDict)(field, path, value);
-    }
-    const parsedParent = {};
-    for (const key in children) {
-        const child = children[key];
-        parsedParent[key] = await parseFieldValue(trx, child.field, [...path, key], raw, child.value, inject);
+        let children;
+        if (field.type === 'obj') {
+            children = (0, parse_1.parseObj)(field, path, value);
+        }
+        else {
+            children = (0, parse_1.parseDict)(field, path, value);
+        }
+        const parsedParent = {};
+        for (const key in children) {
+            const child = children[key];
+            parsedParent[key] = await parseFieldValue(trx, child.field, [...path, key], raw, child.value, inject);
+        }
+        return parsedParent;
     }
-    return parsedParent;
 }
 /**
  * [Parser Step 3-b]: 'id'
@@ -166,12 +160,7 @@ async function parseIdField(trx, field, path, value) {
     const type = field.meta.id.type;
     const view = field.meta.id.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);
-    }
-    else {
-        return parsed.obj;
-    }
+    return parsed.obj;
 }
 function sanitize(field, path, value) {
     if (typeof value === 'function') {
@@ -201,13 +190,9 @@ function isEmpty(value) {
 /**
  * Rules
  */
-async function applyFieldRules(mode, field, path, raw, value, inject) {
+async function applyFieldRules(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;
+    const rules = field.rules;
     for (const r in rules) {
         const rule = rules[r];
         const res = await rule({ field, value, path: path.join('.'), msg: raw, inject });

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

@@ -122,6 +122,7 @@ class InlineApp extends app_1.App {
         Object.values(modules).forEach(module => {
             module.injectDependencies(modules, {
                 buckets: Object.values(module.schema.externals.buckets),
+                messages: Object.values(module.schema.externals.messages),
                 jobs: Object.values(module.schema.externals.jobs),
                 machines: Object.values(module.schema.externals.machines),
             });

package/lib/engine/data/trash.js

@@ -5,14 +5,14 @@ const bucket_schema_1 = require("../../elements/entities/bucket/bucket.schema");
 const bucket_model_schema_1 = require("../../elements/entities/bucket/model/bucket_model.schema");
 const bucket_graph_schema_1 = require("../../elements/entities/bucket/graph/bucket_graph.schema");
 exports.$TrashBucket = new bucket_schema_1.$Bucket('__trash__', 'trash', 'Trash', new bucket_model_schema_1.$BucketModel({
-    id: new bucket_model_schema_1.$BucketModelField('id', 'id', 'int', 'id', false, true),
-    module: new bucket_model_schema_1.$BucketModelField('module', 'module', 'string', 'Module Name', false, true),
-    bucket: new bucket_model_schema_1.$BucketModelField('bucket', 'bucket', 'string', 'Bucket Name', false, true),
-    object_id: new bucket_model_schema_1.$BucketModelField('object_id', 'object_id', 'int', 'Object ID', false, true),
-    object: new bucket_model_schema_1.$BucketModelField('object', 'object', 'dict', 'Object', false, true, undefined, undefined, {
-        __dict: new bucket_model_schema_1.$BucketModelField('', '', 'unknown', '', false, true, undefined, undefined)
+    id: new bucket_model_schema_1.$BucketModelField('id', 'id', 'int', 'id', true),
+    module: new bucket_model_schema_1.$BucketModelField('module', 'module', 'string', 'Module Name', true),
+    bucket: new bucket_model_schema_1.$BucketModelField('bucket', 'bucket', 'string', 'Bucket Name', true),
+    object_id: new bucket_model_schema_1.$BucketModelField('object_id', 'object_id', 'int', 'Object ID', true),
+    object: new bucket_model_schema_1.$BucketModelField('object', 'object', 'dict', 'Object', true, undefined, undefined, {
+        '#': new bucket_model_schema_1.$BucketModelField('', '', 'unknown', '', true, undefined, undefined)
     }),
-    delete_trx_id: new bucket_model_schema_1.$BucketModelField('delete_trx_id', 'delete_trx_id', 'int', 'ID of Delete Transaction', false, true),
+    delete_trx_id: new bucket_model_schema_1.$BucketModelField('delete_trx_id', 'delete_trx_id', 'int', 'ID of Delete Transaction', true),
 }), new bucket_graph_schema_1.$BucketGraph(), {});
 class Trash {
     static async add(trx, module, bucket, object) {

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

@@ -10,7 +10,10 @@ export declare class Tree {
      * - `*`: Return all values of the matched array or dict
      * - `0`: Return the first value of an array or dict (dict ordering is unstable)
      * - `(number|string)[]`: Sequence of values to replace the `#`s on the fieldpath
+     *
+     * @deprecated Fieldpath was consolidated into Modelpath and Querypath.
      */
     static get(obj: Record<string, any>, fieldpath: string, index?: '*' | 0 | (number | string)[]): any;
+    static getModelpath(obj: Record<string, any>, modelpath: string, index: (string | number)[]): any[];
     static set(obj: Record<string, any>, fieldpath: string, replacer: (v: any, i: (number | string)[]) => any, __index?: (number | string)[]): void;
 }

package/lib/engine/data/tree.js

@@ -17,6 +17,8 @@ class Tree {
      * - `*`: Return all values of the matched array or dict
      * - `0`: Return the first value of an array or dict (dict ordering is unstable)
      * - `(number|string)[]`: Sequence of values to replace the `#`s on the fieldpath
+     *
+     * @deprecated Fieldpath was consolidated into Modelpath and Querypath.
      */
     static get(obj, fieldpath, index = '*') {
         index = (!Array.isArray(index)) ? index : [...index];
@@ -90,6 +92,40 @@ class Tree {
         }
         return ref;
     }
+    static getModelpath(obj, modelpath, index) {
+        const paths = modelpath.split('.');
+        let poll = [obj];
+        while (poll.length) {
+            const next = [];
+            for (const item of poll) {
+                const path = paths[item.i];
+                // '*'
+                if (path === '*') {
+                    if (typeof item !== 'object') {
+                        throw new Error(`Can't read *, item is not object (${item})`);
+                    }
+                    next.push(...Object.values(item));
+                }
+                else {
+                    const idx_str = path.match(/^\$(\d+)/)?.[1];
+                    let _path = path;
+                    // $0, $1..
+                    if (idx_str !== undefined) {
+                        const idx = parseInt(idx_str);
+                        if (idx >= index.length) {
+                            throw new Error(`Can't read $${idx}, too few indexes (${index.length})`);
+                        }
+                        _path = index[idx];
+                    }
+                    const n = typeof item === 'object' ? item[_path] : undefined;
+                    if (n)
+                        next.push(n);
+                }
+            }
+            poll = next;
+        }
+        return poll;
+    }
     static set(obj, fieldpath, replacer, __index = []) {
         const paths = fieldpath.split('.');
         class Ptr {

package/lib/engine/util/parse.d.ts

@@ -7,32 +7,32 @@ import { NesoiDatetime } from '../data/datetime';
 import { NesoiFile } from '../data/file';
 import { NesoiDuration } from '../data/duration';
 export declare function parseBoolean(field: {
-    path_raw: string;
+    pathRaw: string;
     alias: string;
 }, path: string[], value: any): boolean;
 export declare function parseDate(field: {
-    path_raw: string;
+    pathRaw: string;
     alias: string;
 }, path: string[], value: any): NesoiDate;
 export declare function parseDatetime(field: {
-    path_raw: string;
+    pathRaw: string;
     alias: string;
 }, path: string[], value: any): NesoiDatetime;
 export declare function parseDuration(field: {
-    path_raw: string;
+    pathRaw: string;
     alias: string;
 }, path: string[], value: any): NesoiDuration;
 export declare function parseDecimal(field: {
-    path_raw: string;
+    pathRaw: string;
     alias: string;
 }, path: string[], value: any): NesoiDecimal;
 export declare function parseEnum(raw: Record<string, any>, field: {
-    path_raw: string;
+    pathRaw: string;
     name: string;
     alias: string;
 }, path: string[], value: any, options: string | readonly string[] | Record<string, any>, trx: AnyTrxNode): any;
 export declare function parseFile(field: {
-    path_raw: string;
+    pathRaw: string;
     name: string;
     alias: string;
 }, path: string[], value: any, options?: {
@@ -40,30 +40,38 @@ export declare function parseFile(field: {
     extnames?: string[];
 }): NesoiFile;
 export declare function parseFloat_(field: {
-    path_raw: string;
+    pathRaw: string;
     alias: string;
 }, path: string[], value: any): number;
 export declare function parseId<M extends $Module, Name extends BucketName<M>, View extends ViewName<M['buckets'][Name]> | undefined>(field: {
-    path_raw: string;
+    pathRaw: string;
     alias: string;
 }, path: string[], value: any, trx: AnyTrxNode, bucket: Name, type?: 'int' | 'string', view?: View): Promise<{
     id: string | number;
     obj: any;
 }>;
 export declare function parseInt_(field: {
-    path_raw: string;
+    pathRaw: string;
     alias: string;
 }, path: string[], value: any): number;
 export declare function parseString(field: {
-    path_raw: string;
+    pathRaw: string;
     alias: string;
 }, path: string[], value: any): string;
 export declare function parseStringOrNumber(field: {
-    path_raw: string;
+    pathRaw: string;
     alias: string;
 }, path: string[], value: any): string | number;
 export declare function parseDict(field: {
-    path_raw: string;
+    pathRaw: string;
+    alias: string;
+    children?: $MessageTemplateFields;
+}, path: string[], value: any): Record<string, {
+    field: $MessageTemplateField;
+    value?: any;
+}>;
+export declare function parseList(field: {
+    pathRaw: string;
     alias: string;
     children?: $MessageTemplateFields;
 }, path: string[], value: any): Record<string, {
@@ -71,7 +79,7 @@ export declare function parseDict(field: {
     value?: any;
 }>;
 export declare function parseObj(field: {
-    path_raw: string;
+    pathRaw: string;
     alias: string;
     children?: $MessageTemplateFields;
 }, path: string[], value: any): Record<string, {

package/lib/engine/util/parse.js

@@ -13,6 +13,7 @@ exports.parseInt_ = parseInt_;
 exports.parseString = parseString;
 exports.parseStringOrNumber = parseStringOrNumber;
 exports.parseDict = parseDict;
+exports.parseList = parseList;
 exports.parseObj = parseObj;
 const date_1 = require("../data/date");
 const error_1 = require("../data/error");
@@ -180,7 +181,7 @@ function parseDict(field, path, value) {
     if (typeof value === 'object') {
         const children = {};
         for (const key in value) {
-            const _field = field.children['__dict'];
+            const _field = field.children['#'];
             children[key] = {
                 field: _field,
                 value: value[key]
@@ -190,6 +191,20 @@ function parseDict(field, path, value) {
     }
     throw error_1.NesoiError.Message.InvalidFieldType({ alias: field.alias, path: path.join('.'), value, type: 'dict' });
 }
+function parseList(field, path, value) {
+    if (!Array.isArray(value)) {
+        throw error_1.NesoiError.Message.InvalidFieldType({ alias: field.alias, path: path.join('.'), value, type: 'list' });
+    }
+    const children = {};
+    for (let i = 0; i < value.length; i++) {
+        const _field = field.children['#'];
+        children[i] = {
+            field: _field,
+            value: value[i]
+        };
+    }
+    return children;
+}
 function parseObj(field, path, value) {
     if (typeof value === 'object') {
         if (!field.children)
@@ -197,8 +212,8 @@ function parseObj(field, path, value) {
         const children = {};
         for (const key in field.children) {
             const _field = field.children[key];
-            const key_raw = _field.path_raw.split('.')[path.length];
-            const key_parsed = _field.path_parsed.split('.')[path.length];
+            const key_raw = _field.pathRaw.split('.')[path.length];
+            const key_parsed = _field.pathParsed.split('.')[path.length];
             children[key_parsed] = {
                 field: _field,
                 value: value[key_raw]

package/lib/engine/util/type.d.ts

@@ -5,3 +5,6 @@ export type MergeUnion<T> = {
         [J in K]: any;
     } ? T[K] : never;
 };
+export type UnionToIntersection<T> = {
+    [K in T as K & string]: K;
+}[any];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "nesoi",
-    "version": "3.0.21",
+    "version": "3.1.0",
     "description": "Declarative framework for data-driven applications",
     "repository": {
         "type": "git",

package/tools/joaquin/bucket.d.ts

@@ -0,0 +1,9 @@
+import { AnyBucketBuilder } from "../../src/elements/entities/bucket/bucket.builder";
+import { NesoiError } from "../../src/engine/data/error";
+import { AnyBuilder } from "../../src/engine/module";
+export declare function expectBucket(def: (builder: AnyBucketBuilder) => any, inject?: AnyBuilder[]): {
+    toBuildOne(raw: Record<string, any>, view: string): {
+        as(parsed: Record<string, any>): Promise<void>;
+        butFail(error: (...args: any[]) => NesoiError.BaseError): Promise<void>;
+    };
+};