nesoi 3.0.20 → 3.1.0

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

@@ -12,9 +12,13 @@ class MessageTemplateFieldFactory {
     constructor(module) {
         this.module = module;
     }
+    /**
+     * Specifies an alias for the field.
+    */
     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);
@@ -74,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);
@@ -101,10 +110,9 @@ 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 = [];
     }
     as(alias) {
@@ -113,99 +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) {
         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._array = this._array;
-        this._or._defaultValue = this._defaultValue;
-        this._or._nullable = this._nullable;
-        this._or._required = this._required;
-        this._or._rules = this._rules;
-        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, 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);
+        // 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.d.ts

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

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

@@ -4,19 +4,34 @@ exports.MessageTemplateFieldParser = MessageTemplateFieldParser;
 exports.isEmpty = isEmpty;
 const parse_1 = require("../../../../engine/util/parse");
 const error_1 = require("../../../../engine/data/error");
-async function MessageTemplateFieldParser(raw, trx, field, value) {
-    return parseFieldValue(trx, field, raw, value, 0);
+// TODO: OPTIMIZATION
+// Parse everything that's static first, then move on to
+// parsing ids etc.
+async function MessageTemplateFieldParser(trx, fields, raw) {
+    const parsed = {};
+    const inject = {};
+    for (const k in fields) {
+        const field = fields[k];
+        const key_raw = field.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);
+    }
+    Object.assign(parsed, inject);
+    return parsed;
 }
-// Attempt to parse a field value
-// - If field is an array, this method is run for each value, sequentially
-// - If not, it's run for the original value, once
-//
-// - This method stacks with the .or options
-//
-async function parseFieldValue(trx, field, raw, value, path_idx) {
+/**
+ * [Parser Step 1]
+ *
+ * - Check for empty fields ({}, [], '', null, undefined)
+ * - If it's array, run step 2 for each value (with this field and path+i)
+ *  - If not, run step 2 for the original value (with this field and path)
+ */
+async function parseFieldValue(trx, field, path, raw, value, inject) {
+    sanitize(field, path, value);
     if (isEmpty(value)) {
         if (field.required) {
-            throw error_1.NesoiError.Message.FieldIsRequired({ field: field.alias, path: field.path_raw, value });
+            throw error_1.NesoiError.Message.FieldIsRequired({ alias: field.alias, path: path.join('.'), value });
         }
         else if (field.defaultValue !== undefined) {
             return field.defaultValue;
@@ -25,100 +40,133 @@ async function parseFieldValue(trx, field, raw, value, path_idx) {
             return undefined;
         }
     }
-    if (field.array) {
-        if (!Array.isArray(value)) {
-            throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path: field.path_raw, value, type: 'list' });
-        }
-        if (field.required && !value.length) {
-            throw error_1.NesoiError.Message.FieldIsRequired({ field: field.alias, path: field.path_raw, value });
-        }
-        const parsedValue = [];
-        for (let i = 0; i < value.length; i++) {
-            const v = value[i];
-            const parsed = await _attemptUnion(trx, field, raw, v, path_idx + 1);
-            parsedValue.push(parsed);
-        }
-        return parsedValue;
-    }
-    return _attemptUnion(trx, field, raw, value, path_idx);
+    let output = await _attemptUnion(trx, field, path, raw, value, inject);
+    output = await applyFieldRules(field, path, raw, output, inject);
+    return output;
 }
-async function _attemptUnion(trx, field, raw, value, path_idx, unionErrors = []) {
-    try {
-        return await _runParseMethod(trx, field, raw, value, path_idx);
+/**
+ * [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) {
+    if (field.type !== 'union') {
+        return _runParseMethod(trx, field, path, raw, value, inject);
     }
-    catch (e) {
-        // If failed and there's a second option, atempt it
-        if (field.or) {
-            return await _attemptUnion(trx, field.or, raw, value, path_idx, [...unionErrors, e]);
+    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;
         }
-        // If this error was not the first attempt, and we have no other option
-        // we throw a specific error
-        // This avoid confusion for the client when parsing unions
-        if (unionErrors.length) {
-            throw error_1.NesoiError.Message.ValueDoesntMatchUnion({ field: field.alias, path: field.path_raw, value, unionErrors: [...unionErrors, e] });
+        catch (e) {
+            unionErrors.push({
+                option: option.alias,
+                name: e.name,
+                status: e.status,
+                message: e.message,
+                data: e.data,
+            });
         }
-        throw e;
     }
+    if (unionErrors.length === Object.keys(field.children).length) {
+        throw error_1.NesoiError.Message.ValueDoesntMatchUnion({ alias: field.alias, path: path.join('.'), value, unionErrors });
+    }
+    return output;
 }
-async function _runParseMethod(trx, field, raw, value, path_idx) {
+/**
+ * [Parser Step 3]
+ *
+ * - Run a specific parsing method based on the field type
+ */
+async function _runParseMethod(trx, field, path, raw, value, inject) {
     switch (field.type) {
         case 'obj':
         case 'dict':
-            return await parseParentField(trx, field, raw, value, path_idx);
+        case 'list':
+            return parseParentField(trx, field, path, raw, value, inject);
         case 'unknown':
             return value;
         case 'boolean':
-            return (0, parse_1.parseBoolean)(field, value);
+            return (0, parse_1.parseBoolean)(field, path, value);
         case 'date':
-            return (0, parse_1.parseDate)(field, value);
+            return (0, parse_1.parseDate)(field, path, value);
         case 'datetime':
-            return (0, parse_1.parseDatetime)(field, value);
+            return (0, parse_1.parseDatetime)(field, path, value);
         case 'duration':
-            return (0, parse_1.parseDuration)(field, value);
+            return (0, parse_1.parseDuration)(field, path, value);
         case 'decimal':
-            return (0, parse_1.parseDecimal)(field, value);
+            return (0, parse_1.parseDecimal)(field, path, value);
         case 'enum':
-            return (0, parse_1.parseEnum)(raw, field, value, field.meta.enum.options, trx);
+            return (0, parse_1.parseEnum)(raw, field, path, value, field.meta.enum.options, trx);
         case 'file':
-            return (0, parse_1.parseFile)(field, value, field.meta.file);
+            return (0, parse_1.parseFile)(field, path, value, field.meta.file);
         case 'float':
-            return (0, parse_1.parseFloat_)(field, value);
+            return (0, parse_1.parseFloat_)(field, path, value);
         case 'int':
-            return (0, parse_1.parseInt_)(field, value);
+            return (0, parse_1.parseInt_)(field, path, value);
         case 'string':
-            return (0, parse_1.parseString)(field, value);
+            return (0, parse_1.parseString)(field, path, value);
         case 'string_or_number':
-            return (0, parse_1.parseStringOrNumber)(field, value);
+            return (0, parse_1.parseStringOrNumber)(field, path, value);
         case 'id':
-            return await parseIdField(trx, field, value);
+            return parseIdField(trx, field, path, value);
     }
     throw error_1.NesoiError.Builder.Message.UnknownTemplateFieldType(field.type);
 }
-async function parseParentField(trx, field, raw, value, path_idx) {
-    let children;
-    if (field.type === 'obj') {
-        children = (0, parse_1.parseObj)(field, value, path_idx);
+/**
+ * [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) {
+    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, value);
-    }
-    const parsed = {};
-    for (const key in children) {
-        const child = children[key];
-        parsed[key] = await parseFieldValue(trx, child.field, raw, child.value, path_idx + 1);
+        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 parsed;
 }
-async function parseIdField(trx, field, value) {
+/**
+ * [Parser Step 3-b]: 'id'
+ *
+ * - Gathers the data for parsing a id
+ */
+async function parseIdField(trx, field, path, value) {
     const bucket = field.meta.id.bucket;
     const type = field.meta.id.type;
     const view = field.meta.id.view;
-    const parsed = await (0, parse_1.parseId)(field, value, trx, bucket.refName, type, view);
-    if (field.array) {
-        return parsed.map((p) => p.obj);
-    }
-    else {
-        return parsed.obj;
+    const parsed = await (0, parse_1.parseId)(field, path, value, trx, bucket.refName, type, view);
+    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.'
+        });
     }
 }
 /**
@@ -139,3 +187,21 @@ function isEmpty(value) {
     }
     return false;
 }
+/**
+ * Rules
+ */
+async function applyFieldRules(field, path, raw, value, inject) {
+    let output = value;
+    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 });
+        if (typeof res === 'object') {
+            output = res.set;
+        }
+        else if (res !== true) {
+            throw error_1.NesoiError.Message.RuleFailed({ alias: field.alias, path: path.join('.'), rule, error: res });
+        }
+    }
+    return output;
+}

package/lib/engine/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/error.d.ts

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

package/lib/engine/data/error.js

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

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;
 }