nesoi 3.0.21 → 3.1.1

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);
     }
@@ -29,33 +29,22 @@ async function MessageTemplateFieldParser(trx, fields, raw) {
  */
 async function parseFieldValue(trx, field, path, raw, value, inject) {
     sanitize(field, path, value);
+    let output;
     if (isEmpty(value)) {
         if (field.required) {
             throw error_1.NesoiError.Message.FieldIsRequired({ alias: field.alias, path: path.join('.'), value });
         }
         else if (field.defaultValue !== undefined) {
-            return field.defaultValue;
+            output = field.defaultValue;
         }
         else {
-            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 = undefined;
         }
-        output = await applyFieldRules('array', field, path, raw, output, inject);
     }
     else {
         output = await _attemptUnion(trx, field, path, raw, value, inject);
     }
+    output = await applyFieldRules(field, path, raw, output, inject);
     return output;
 }
 /**
@@ -65,35 +54,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 +90,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 +117,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 +163,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 +193,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/space.js

@@ -301,7 +301,7 @@ class Space {
                 .filter(node => node.isDirectory());
             for (const dir of dirs) {
                 const modulePath = path.join(dirpath, dir.name);
-                if (fs.existsSync(path.join(modulePath, '.modules'))) {
+                if (fs.existsSync(path.join(modulePath, '.subset'))) {
                     perform(modulePath, [...subdir, dir.name]);
                 }
                 else {

package/lib/engine/transaction/trx_engine.config.d.ts

@@ -1,13 +1,14 @@
 import { $Module, $Space } from "../../elements";
 import { BucketAdapter } from "../../elements/entities/bucket/adapters/bucket_adapter";
-import { AnyTrx, Trx } from './trx';
+import { Trx } from './trx';
 import { AnyUsers } from '../auth/authn';
 import { TrxNode, TrxNodeStatus } from './trx_node';
+import { TrxData } from './trx_engine';
 export type TrxEngineWrapFn<S extends $Space, M extends $Module> = (trx: TrxNode<S, M, any>) => Promise<TrxNodeStatus>;
 export type TrxEngineConfig<S extends $Space, M extends $Module, Authn extends AnyUsers, Services extends Record<string, any>> = {
     /**
      * Adapter used to store transactions of this module.
      */
-    adapter?: (schema: M) => BucketAdapter<AnyTrx>;
+    adapter?: (schema: M) => BucketAdapter<TrxData>;
     wrap?: <T extends Trx<S, M, Authn>>(trx: T, fn: TrxEngineWrapFn<S, M>, services: Services) => Promise<any>;
 };

package/lib/engine/transaction/trx_engine.d.ts

@@ -1,11 +1,18 @@
 import { $Module, $Space } from "../../schema";
 import { Module } from '../module';
-import { Trx } from './trx';
+import { AnyTrx, Trx } from './trx';
 import { TrxNode, TrxNodeStatus } from './trx_node';
 import { AnyAuthnProviders, AuthnRequest } from '../auth/authn';
 import { TrxEngineConfig } from './trx_engine.config';
 import { IService } from '../apps/service';
 export type TrxEngineOrigin = `app:${string}` | `plugin:${string}`;
+export type TrxData = {
+    id: AnyTrx['id'];
+    origin: AnyTrx['origin'];
+    module: string;
+    start: AnyTrx['start'];
+    end: AnyTrx['end'];
+};
 /**
  * @category Engine
  * @subcategory Transaction
@@ -16,6 +23,7 @@ export declare class TrxEngine<S extends $Space, M extends $Module, Authn extend
     private authnProviders?;
     private config?;
     private services;
+    private $TrxBucket;
     /**
      * Transaction used to read/write transactions on the adapter
      */

package/lib/engine/transaction/trx_engine.js

@@ -6,6 +6,9 @@ const trx_1 = require("./trx");
 const trx_node_1 = require("./trx_node");
 const error_1 = require("../data/error");
 const memory_bucket_adapter_1 = require("../../elements/entities/bucket/adapters/memory.bucket_adapter");
+const elements_1 = require("../../elements");
+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");
 /**
  * @category Engine
  * @subcategory Transaction
@@ -17,28 +20,56 @@ class TrxEngine {
         this.authnProviders = authnProviders;
         this.config = config;
         this.services = services;
+        this.$TrxBucket = new elements_1.$Bucket(this.module.name, '__trx__', `Transaction of Module '${this.module.name}'`, new bucket_model_schema_1.$BucketModel({
+            id: new bucket_model_schema_1.$BucketModelField('id', 'id', 'string', 'ID', true),
+            origin: new bucket_model_schema_1.$BucketModelField('origin', 'origin', 'string', 'Origin', true),
+            module: new bucket_model_schema_1.$BucketModelField('module', 'module', 'string', 'Module', true),
+            start: new bucket_model_schema_1.$BucketModelField('start', 'start', 'datetime', 'Start', true),
+            end: new bucket_model_schema_1.$BucketModelField('end', 'end', 'datetime', 'Start', false),
+        }), new bucket_graph_schema_1.$BucketGraph(), {});
         this.innerTrx = new trx_1.Trx(this, this.module, `trx:${origin}`);
-        this.adapter = config?.adapter?.(module.schema) || new memory_bucket_adapter_1.MemoryBucketAdapter({}, {});
+        this.adapter = config?.adapter?.(module.schema) || new memory_bucket_adapter_1.MemoryBucketAdapter(this.$TrxBucket, {});
     }
     getModule() {
         return this.module;
     }
     async get(id) {
-        let trx = undefined;
+        let trx;
         if (!id) {
             trx = new trx_1.Trx(this, this.module, this.origin);
             log_1.Log.info('module', this.module.name, `Begin ${(0, log_1.scopeTag)('trx', trx.id)} @ ${(0, log_1.anyScopeTag)(this.origin)}`);
-            return this.adapter.create(this.innerTrx.root, trx);
+            await this.adapter.create(this.innerTrx.root, {
+                id: trx.id,
+                origin: trx.origin,
+                start: trx.start,
+                end: trx.end,
+                module: this.module.name
+            });
+            return trx;
         }
         else {
-            trx = await this.adapter.get(this.innerTrx.root, id);
-            if (trx) {
-                log_1.Log.info('module', this.module.name, `Continue ${(0, log_1.scopeTag)('trx', trx.id)} @ ${(0, log_1.anyScopeTag)(this.origin)}`);
+            const trxData = await this.adapter.get(this.innerTrx.root, id);
+            if (trxData) {
+                log_1.Log.info('module', this.module.name, `Continue ${(0, log_1.scopeTag)('trx', trxData.id)} @ ${(0, log_1.anyScopeTag)(this.origin)}`);
+                // Objects read from adapters are not the proper JS class, so they don't
+                // carry methods. This must be used to recover the methods.
+                trx = Object.assign(new trx_1.Trx(this, this.module, this.origin), {
+                    id: trxData.id,
+                    origin: trxData.origin,
+                    start: trxData.start,
+                    end: trxData.end
+                });
             }
             else {
                 log_1.Log.info('module', this.module.name, `Chain ${(0, log_1.scopeTag)('trx', id)} @ ${(0, log_1.anyScopeTag)(this.origin)}`);
                 trx = new trx_1.Trx(this, this.module, this.origin, undefined, id);
-                return this.adapter.create(this.innerTrx.root, trx);
+                await this.adapter.create(this.innerTrx.root, {
+                    id: trx.id,
+                    origin: this.origin,
+                    start: trx.start,
+                    end: trx.end,
+                    module: this.module.name
+                });
             }
         }
         return trx;
@@ -87,7 +118,13 @@ class TrxEngine {
         log_1.Log.info('module', this.module.name, `Commit ${(0, log_1.scopeTag)('trx', trx.id)} @ ${(0, log_1.anyScopeTag)(this.origin)}`);
         await trx_node_1.TrxNode.ok(trx.root, output);
         trx_1.Trx.onFinish(trx);
-        await this.adapter.put(this.innerTrx.root, trx);
+        await this.adapter.put(this.innerTrx.root, {
+            id: trx.id,
+            origin: this.origin,
+            start: trx.start,
+            end: trx.end,
+            module: this.module.name
+        });
         return trx;
     }
     async rollback(trx, error) {
@@ -95,7 +132,13 @@ class TrxEngine {
         log_1.Log.warn('module', this.module.name, `Rollback ${(0, log_1.scopeTag)('trx', trx.id)} @ ${(0, log_1.anyScopeTag)(this.origin)}`);
         await trx_node_1.TrxNode.error(trx.root, error);
         trx_1.Trx.onFinish(trx);
-        await this.adapter.put(this.innerTrx.root, trx);
+        await this.adapter.put(this.innerTrx.root, {
+            id: trx.id,
+            origin: this.origin,
+            start: trx.start,
+            end: trx.end,
+            module: this.module.name
+        });
         return trx;
     }
 }

package/lib/engine/util/deep.js

@@ -10,6 +10,8 @@ class Deep {
             for (const [obj, copy] of poll) {
                 if (Array.isArray(obj)) {
                     for (const item of obj) {
+                        if (typeof item === 'function')
+                            continue;
                         if (item === null) {
                             copy.push(null);
                         }
@@ -26,6 +28,8 @@ class Deep {
                 else {
                     for (const key in obj) {
                         const item = obj[key];
+                        if (typeof item === 'function')
+                            continue;
                         if (item === null) {
                             copy[key] = null;
                         }

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");
@@ -65,12 +66,12 @@ function parseEnum(raw, field, path, value, options, trx) {
             const enumPath = enumName.match(/(.*)\.\{(.*)\}$/);
             let _enum;
             if (enumPath) {
-                enumName += enumPath[1] + '.' + enumPath[2];
+                const v = tree_1.Tree.get(raw, enumPath[2]);
+                enumName = enumPath[1] + '.' + v;
                 try {
                     _enum = trx.enum(enumName);
                 }
                 catch {
-                    const v = tree_1.Tree.get(raw, enumPath[2]);
                     throw error_1.NesoiError.Message.InvalidEnumScope({ alias: field.alias, path: path.join('.'), value: v, fieldpath: enumPath[2] });
                 }
             }
@@ -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.1",
     "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>;
+    };
+};