nesoi 3.0.19 → 3.0.21

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/util/deep.d.ts

@@ -8,5 +8,7 @@ export type DeepPartialNullable<T> = UndefinedToOptional<T extends object ? {
 type Obj = Record<string, any>;
 export declare class Deep {
     static copy<T extends Obj>(obj: T): T;
+    static get(obj: Record<string, any>, path: string): any;
+    static set(obj: Record<string, any>, path: string, value: any): void;
 }
 export {};

package/lib/engine/util/deep.js

@@ -44,5 +44,35 @@ class Deep {
         }
         return copy;
     }
+    static get(obj, path) {
+        if (!path) {
+            return undefined;
+        }
+        const props = path.split('.');
+        let val = obj;
+        for (const p in props) {
+            val = val[props[p]];
+            if (val === undefined) {
+                return undefined;
+            }
+        }
+        return val;
+    }
+    static set(obj, path, value) {
+        const props = path.split('.');
+        let val = obj;
+        for (const p in props) {
+            const prop = props[p];
+            if (val[prop] === undefined) {
+                val[prop] = {};
+            }
+            if (parseInt(p) < props.length - 1) {
+                val = val[prop];
+            }
+            else {
+                val[prop] = value;
+            }
+        }
+    }
 }
 exports.Deep = Deep;

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

@@ -7,56 +7,66 @@ import { NesoiDatetime } from '../data/datetime';
 import { NesoiFile } from '../data/file';
 import { NesoiDuration } from '../data/duration';
 export declare function parseBoolean(field: {
+    path_raw: string;
     alias: string;
-}, path: string, value: any): boolean;
+}, path: string[], value: any): boolean;
 export declare function parseDate(field: {
+    path_raw: string;
     alias: string;
-}, path: string, value: any): NesoiDate;
+}, path: string[], value: any): NesoiDate;
 export declare function parseDatetime(field: {
+    path_raw: string;
     alias: string;
-}, path: string, value: any): NesoiDatetime;
+}, path: string[], value: any): NesoiDatetime;
 export declare function parseDuration(field: {
+    path_raw: string;
     alias: string;
-}, path: string, value: any): NesoiDuration;
+}, path: string[], value: any): NesoiDuration;
 export declare function parseDecimal(field: {
+    path_raw: string;
     alias: string;
-}, path: string, value: any): NesoiDecimal;
+}, path: string[], value: any): NesoiDecimal;
 export declare function parseEnum(raw: Record<string, any>, field: {
+    path_raw: string;
     name: string;
     alias: string;
-}, path: string, value: any, options: string | readonly string[] | Record<string, any>, trx: AnyTrxNode): any;
+}, path: string[], value: any, options: string | readonly string[] | Record<string, any>, trx: AnyTrxNode): any;
 export declare function parseFile(field: {
+    path_raw: string;
     name: string;
     alias: string;
-}, path: string, value: any, options?: {
+}, path: string[], value: any, options?: {
     maxsize?: number;
     extnames?: string[];
 }): NesoiFile;
 export declare function parseFloat_(field: {
+    path_raw: string;
     alias: string;
-}, path: string, value: any): number;
+}, 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;
     alias: string;
-}, path: string, value: any, trx: AnyTrxNode, bucket: Name, type?: 'int' | 'string', view?: View): Promise<{
-    value: {
-        id: string | number;
-        obj: any;
-    };
+}, 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;
     alias: string;
-}, path: string, value: any): number;
+}, path: string[], value: any): number;
 export declare function parseString(field: {
+    path_raw: string;
     alias: string;
-}, path: string, value: any): string;
+}, path: string[], value: any): string;
 export declare function parseStringOrNumber(field: {
+    path_raw: string;
     alias: string;
-}, path: string, value: any): string | number;
+}, path: string[], value: any): string | number;
 export declare function parseDict(field: {
     path_raw: string;
     alias: string;
     children?: $MessageTemplateFields;
-}, path: string, value: any): Record<string, {
+}, path: string[], value: any): Record<string, {
     field: $MessageTemplateField;
     value?: any;
 }>;
@@ -64,7 +74,7 @@ export declare function parseObj(field: {
     path_raw: string;
     alias: string;
     children?: $MessageTemplateFields;
-}, path: string, value: any): Record<string, {
+}, path: string[], value: any): Record<string, {
     field: $MessageTemplateField;
     value?: any;
 }>;

package/lib/engine/util/parse.js

@@ -31,32 +31,32 @@ function parseBoolean(field, path, value) {
     if (typeof value === 'boolean') {
         return value;
     }
-    throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path, value, type: 'boolean' });
+    throw error_1.NesoiError.Message.InvalidFieldType({ alias: field.alias, path: path.join('.'), value, type: 'boolean' });
 }
 function parseDate(field, path, value) {
     // TODO: limit to date
     if (typeof value === 'string') {
         return date_1.NesoiDate.fromISO(value);
     }
-    throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path, value, type: 'date' });
+    throw error_1.NesoiError.Message.InvalidFieldType({ alias: field.alias, path: path.join('.'), value, type: 'date' });
 }
 function parseDatetime(field, path, value) {
     if (typeof value === 'string') {
         return datetime_1.NesoiDatetime.fromISO(value);
     }
-    throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path, value, type: 'datetime' });
+    throw error_1.NesoiError.Message.InvalidFieldType({ alias: field.alias, path: path.join('.'), value, type: 'datetime' });
 }
 function parseDuration(field, path, value) {
     if (typeof value === 'string') {
         return duration_1.NesoiDuration.fromString(value);
     }
-    throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path, value, type: 'duration' });
+    throw error_1.NesoiError.Message.InvalidFieldType({ alias: field.alias, path: path.join('.'), value, type: 'duration' });
 }
 function parseDecimal(field, path, value) {
     if (typeof value === 'string') {
         return new decimal_1.NesoiDecimal(value);
     }
-    throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path, value, type: 'decimal' });
+    throw error_1.NesoiError.Message.InvalidFieldType({ alias: field.alias, path: path.join('.'), value, type: 'decimal' });
 }
 function parseEnum(raw, field, path, value, options, trx) {
     if (typeof value === 'string') {
@@ -71,7 +71,7 @@ function parseEnum(raw, field, path, value, options, trx) {
                 }
                 catch {
                     const v = tree_1.Tree.get(raw, enumPath[2]);
-                    throw error_1.NesoiError.Message.InvalidEnumScope({ path, name: field.name, alias: field.alias, value: v, fieldpath: enumPath[2] });
+                    throw error_1.NesoiError.Message.InvalidEnumScope({ alias: field.alias, path: path.join('.'), value: v, fieldpath: enumPath[2] });
                 }
             }
             else {
@@ -82,7 +82,7 @@ function parseEnum(raw, field, path, value, options, trx) {
                 return value;
             }
             else {
-                throw error_1.NesoiError.Message.InvalidFieldEnumValue({ field: field.alias, path, value, type: 'enum', options: keys });
+                throw error_1.NesoiError.Message.InvalidFieldEnumValue({ alias: field.alias, path: path.join('.'), value, type: 'enum', options: keys });
             }
         }
         else if (Array.isArray(options)) {
@@ -90,7 +90,7 @@ function parseEnum(raw, field, path, value, options, trx) {
                 return value;
             }
             else {
-                throw error_1.NesoiError.Message.InvalidFieldEnumValue({ field: field.alias, path, value, type: 'enum', options });
+                throw error_1.NesoiError.Message.InvalidFieldEnumValue({ alias: field.alias, path: path.join('.'), value, type: 'enum', options });
             }
         }
         else if (typeof options === 'object') {
@@ -98,29 +98,24 @@ function parseEnum(raw, field, path, value, options, trx) {
                 return options[value];
             }
             else {
-                throw error_1.NesoiError.Message.InvalidFieldEnumValue({ field: field.alias, path, value, type: 'enum', options: Object.keys(options) });
+                throw error_1.NesoiError.Message.InvalidFieldEnumValue({ alias: field.alias, path: path.join('.'), value, type: 'enum', options: Object.keys(options) });
             }
         }
     }
-    throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path, value, type: 'string' });
+    throw error_1.NesoiError.Message.InvalidFieldType({ alias: field.alias, path: path.join('.'), value, type: 'string' });
 }
 function parseFile(field, path, value, options) {
     if (!(value instanceof file_1.NesoiFile)) {
-        throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path, value, type: 'file' });
+        throw error_1.NesoiError.Message.InvalidFieldType({ alias: field.alias, path: path.join('.'), value, type: 'file' });
     }
     if (options?.maxsize) {
         if (value.size > options?.maxsize) {
-            throw error_1.NesoiError.Message.FileTooBig({
-                path,
-                name: field.name,
-                alias: field.alias,
-                maxsize: options?.maxsize
-            });
+            throw error_1.NesoiError.Message.FileTooBig({ alias: field.alias, path: path.join('.'), maxsize: options?.maxsize });
         }
     }
     if (options?.extnames) {
         if (!options?.extnames.includes(value.extname)) {
-            throw error_1.NesoiError.Message.FileExtNotAllowed({ path, name: field.name, alias: field.alias, options: options?.extnames });
+            throw error_1.NesoiError.Message.FileExtNotAllowed({ alias: field.alias, path: path.join('.'), options: options?.extnames });
         }
     }
     return value;
@@ -137,7 +132,7 @@ function parseFloat_(field, path, value) {
             return value;
         }
     }
-    throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path, value, type: 'float' });
+    throw error_1.NesoiError.Message.InvalidFieldType({ alias: field.alias, path: path.join('.'), value, type: 'float' });
 }
 async function parseId(field, path, value, trx, bucket, type, view) {
     let val;
@@ -148,12 +143,10 @@ async function parseId(field, path, value, trx, bucket, type, view) {
         val = parseInt_(field, path, value);
     }
     return {
-        value: {
-            id: val,
-            obj: view
-                ? await trx.bucket(bucket).viewOneOrFail(val, view)
-                : await trx.bucket(bucket).readOneOrFail(val)
-        }
+        id: val,
+        obj: view
+            ? await trx.bucket(bucket).viewOneOrFail(val, view)
+            : await trx.bucket(bucket).readOneOrFail(val)
     };
 }
 function parseInt_(field, path, value) {
@@ -169,32 +162,33 @@ function parseInt_(field, path, value) {
             return val;
         }
     }
-    throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path, value, type: 'integer' });
+    throw error_1.NesoiError.Message.InvalidFieldType({ alias: field.alias, path: path.join('.'), value, type: 'integer' });
 }
 function parseString(field, path, value) {
     if (typeof value === 'string') {
         return value;
     }
-    throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path, value, type: 'string' });
+    throw error_1.NesoiError.Message.InvalidFieldType({ alias: field.alias, path: path.join('.'), value, type: 'string' });
 }
 function parseStringOrNumber(field, path, value) {
     if (typeof value === 'string' || typeof value === 'number') {
         return value;
     }
-    throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path, value, type: 'string_or_number' });
+    throw error_1.NesoiError.Message.InvalidFieldType({ alias: field.alias, path: path.join('.'), value, type: 'string_or_number' });
 }
 function parseDict(field, path, value) {
     if (typeof value === 'object') {
         const children = {};
         for (const key in value) {
+            const _field = field.children['__dict'];
             children[key] = {
-                field: field.children['__dict'],
+                field: _field,
                 value: value[key]
             };
         }
         return children;
     }
-    throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path, value, type: 'dict' });
+    throw error_1.NesoiError.Message.InvalidFieldType({ alias: field.alias, path: path.join('.'), value, type: 'dict' });
 }
 function parseObj(field, path, value) {
     if (typeof value === 'object') {
@@ -202,12 +196,15 @@ function parseObj(field, path, value) {
             return {};
         const children = {};
         for (const key in field.children) {
-            children[key] = {
-                field: field.children[key],
-                value: value[key]
+            const _field = field.children[key];
+            const key_raw = _field.path_raw.split('.')[path.length];
+            const key_parsed = _field.path_parsed.split('.')[path.length];
+            children[key_parsed] = {
+                field: _field,
+                value: value[key_raw]
             };
         }
         return children;
     }
-    throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path, value, type: 'object' });
+    throw error_1.NesoiError.Message.InvalidFieldType({ alias: field.alias, path: path.join('.'), value, type: 'object' });
 }

package/package.json

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