nesoi 3.0.18 → 3.0.20

package/lib/elements/entities/message/template/message_template_field.builder.d.ts

@@ -236,8 +236,8 @@ Nullable extends [null | never, null | never] = [never, never]> {
     rule(rule: MessageTemplateRuleDef<DefinedOutput[keyof DefinedOutput], Message['#raw']>): this;
     get array(): MessageTemplateFieldBuilder<Module, Message, { [K in keyof DefinedInput]: DefinedInput[K][]; }, { [K in keyof DefinedOutput]: DefinedOutput[K][]; }, Children, Optional, Nullable>;
     or<Def extends AnyMessageTemplateFieldBuilder>(def: Def): MessageTemplateFieldBuilder<Module, Message, { [K in keyof DefinedInput]: DefinedInput[K] | (Def extends MessageTemplateFieldBuilder<any, any, infer X, any, any, [never, never], [never, never]> ? X : never)[keyof (Def extends MessageTemplateFieldBuilder<any, any, infer X, any, any, [never, never], [never, never]> ? X : never)]; }, { [K in keyof DefinedOutput]: DefinedOutput[K] | (Def extends MessageTemplateFieldBuilder<any, any, any, infer X, any, [never, never], [never, never]> ? X : never)[keyof (Def extends MessageTemplateFieldBuilder<any, any, any, infer X, any, [never, never], [never, never]> ? X : never)]; }, Children, Optional, Nullable>;
-    static build(builder: AnyMessageTemplateFieldBuilder, name: string, tree: ModuleTree, module: $Module, basePath: string): $MessageTemplateField;
-    static buildChildren(fields: MessageTemplateFieldBuilders, tree: ModuleTree, module: $Module, basePath?: string): $MessageTemplateFields;
+    static build(builder: AnyMessageTemplateFieldBuilder, name: string, tree: ModuleTree, module: $Module, basePathRaw: string, basePathParsed: string): $MessageTemplateField;
+    static buildChildren(fields: MessageTemplateFieldBuilders, tree: ModuleTree, module: $Module, basePathRaw?: string, basePathParsed?: string): $MessageTemplateFields;
 }
 export type MessageTemplateFieldBuilders = {
     [x: string]: AnyMessageTemplateFieldBuilder;

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

@@ -157,21 +157,23 @@ class MessageTemplateFieldBuilder {
         return this;
     }
     // Build
-    static build(builder, name, tree, module, basePath) {
+    static build(builder, name, tree, module, basePathRaw, basePathParsed) {
         const or = builder._or
-            ? this.build(builder._or, name, tree, module, basePath)
-            : undefined;
-        const path = basePath + name + (builder.type === 'id' ? '_id' : '') + '.';
-        const childrenBasePath = builder.children
-            ? path + (builder._array ? '*.' : '')
+            ? this.build(builder._or, name, tree, module, basePathRaw, basePathParsed)
             : undefined;
+        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 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, basePath + name, builder._array, builder._required, builder._defaultValue, builder._nullable, builder._rules, builder.value, builder.children ? MessageTemplateFieldBuilder.buildChildren(builder.children, tree, module, childrenBasePath) : undefined, or);
+        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);
     }
-    static buildChildren(fields, tree, module, basePath = '') {
+    static buildChildren(fields, tree, module, basePathRaw = '', basePathParsed = '') {
         const schema = {};
         for (const c in fields) {
             const child = fields[c];
@@ -197,13 +199,13 @@ class MessageTemplateFieldBuilder {
                 builder._nullable = child._nullable;
                 builder._rules = child._rules.slice(0, -1);
                 builder.children = child.children;
-                schema[param] = MessageTemplateFieldBuilder.build(builder, c, tree, module, basePath);
+                schema[param] = MessageTemplateFieldBuilder.build(builder, c, tree, module, basePathRaw, basePathParsed);
                 schema[param].children = schema[param].children || {};
                 Object.assign(schema[param].children, $msg.template.fields);
                 continue;
             }
             // All other parameters are built directly
-            schema[param] = MessageTemplateFieldBuilder.build(child, c, tree, module, basePath);
+            schema[param] = MessageTemplateFieldBuilder.build(child, c, tree, module, basePathRaw, basePathParsed);
         }
         return schema;
     }

package/lib/elements/entities/message/template/message_template_parser.d.ts

@@ -1,3 +1,7 @@
-import { $MessageTemplateField, $MessageTemplateFields } from './message_template.schema';
+import { $MessageTemplateField } 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, parseFields: (trx: AnyTrxNode, fields: $MessageTemplateFields, obj: Record<string, any>) => any): Promise<Record<string, any>>;
+export declare function MessageTemplateFieldParser(raw: Record<string, any>, trx: AnyTrxNode, field: $MessageTemplateField, value: any): Promise<any>;
+/**
+ * Empty values: `{}`, `[]`, `''`, `null`, `undefined`
+ */
+export declare function isEmpty(value: any): boolean;

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

@@ -1,96 +1,141 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 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, parseFields) {
-    if (field.type === 'unknown') {
-        return {
-            '': value
-        };
-    }
-    if (field.type === 'boolean') {
-        return {
-            '': await (0, parse_1.parseBoolean)(field, value, field.array)
-        };
+async function MessageTemplateFieldParser(raw, trx, field, value) {
+    return parseFieldValue(trx, field, raw, value, 0);
+}
+// 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) {
+    if (isEmpty(value)) {
+        if (field.required) {
+            throw error_1.NesoiError.Message.FieldIsRequired({ field: field.alias, path: field.path_raw, value });
+        }
+        else if (field.defaultValue !== undefined) {
+            return field.defaultValue;
+        }
+        else {
+            return undefined;
+        }
     }
-    if (field.type === 'date') {
-        return {
-            '': await (0, parse_1.parseDate)(field, value, field.array)
-        };
+    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;
     }
-    if (field.type === 'datetime') {
-        return {
-            '': await (0, parse_1.parseDatetime)(field, value, field.array)
-        };
+    return _attemptUnion(trx, field, raw, value, path_idx);
+}
+async function _attemptUnion(trx, field, raw, value, path_idx, unionErrors = []) {
+    try {
+        return await _runParseMethod(trx, field, raw, value, path_idx);
     }
-    if (field.type === 'duration') {
-        return {
-            '': await (0, parse_1.parseDuration)(field, value, field.array)
-        };
+    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]);
+        }
+        // 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] });
+        }
+        throw e;
     }
-    if (field.type === 'decimal') {
-        return {
-            '': await (0, parse_1.parseDecimal)(field, value, field.array)
-        };
+}
+async function _runParseMethod(trx, field, raw, value, path_idx) {
+    switch (field.type) {
+        case 'obj':
+        case 'dict':
+            return await parseParentField(trx, field, raw, value, path_idx);
+        case 'unknown':
+            return value;
+        case 'boolean':
+            return (0, parse_1.parseBoolean)(field, value);
+        case 'date':
+            return (0, parse_1.parseDate)(field, value);
+        case 'datetime':
+            return (0, parse_1.parseDatetime)(field, value);
+        case 'duration':
+            return (0, parse_1.parseDuration)(field, value);
+        case 'decimal':
+            return (0, parse_1.parseDecimal)(field, value);
+        case 'enum':
+            return (0, parse_1.parseEnum)(raw, field, value, field.meta.enum.options, trx);
+        case 'file':
+            return (0, parse_1.parseFile)(field, value, field.meta.file);
+        case 'float':
+            return (0, parse_1.parseFloat_)(field, value);
+        case 'int':
+            return (0, parse_1.parseInt_)(field, value);
+        case 'string':
+            return (0, parse_1.parseString)(field, value);
+        case 'string_or_number':
+            return (0, parse_1.parseStringOrNumber)(field, value);
+        case 'id':
+            return await parseIdField(trx, field, value);
     }
-    if (field.type === 'enum') {
-        const options = field.meta.enum.options;
-        return {
-            '': await (0, parse_1.parseEnum)(raw, field, value, field.array, options, trx)
-        };
+    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);
     }
-    if (field.type === 'file') {
-        const config = field.meta.file;
-        return {
-            '': await (0, parse_1.parseFile)(field, value, field.array, config)
-        };
+    else {
+        children = (0, parse_1.parseDict)(field, value);
     }
-    if (field.type === 'float') {
-        return {
-            '': await (0, parse_1.parseFloat_)(field, value, field.array)
-        };
+    const parsed = {};
+    for (const key in children) {
+        const child = children[key];
+        parsed[key] = await parseFieldValue(trx, child.field, raw, child.value, path_idx + 1);
     }
-    if (field.type === 'id') {
-        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, field.array, trx, bucket.refName, type, view);
-        if (field.array) {
-            return {
-                '': parsed.map((p) => p.obj)
-            };
-        }
-        else {
-            return {
-                '': parsed.obj
-            };
-        }
+    return parsed;
+}
+async function parseIdField(trx, field, 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);
     }
-    if (field.type === 'int') {
-        return {
-            '': await (0, parse_1.parseInt_)(field, value, field.array)
-        };
+    else {
+        return parsed.obj;
     }
-    if (field.type === 'string') {
-        return {
-            '': await (0, parse_1.parseString)(field, value, field.array)
-        };
+}
+/**
+ * Empty values: `{}`, `[]`, `''`, `null`, `undefined`
+ */
+function isEmpty(value) {
+    if (value === null || value === undefined) {
+        return true;
     }
-    if (field.type === 'string_or_number') {
-        return {
-            '': await (0, parse_1.parseStringOrNumber)(field, value, field.array)
-        };
+    if (Array.isArray(value)) {
+        return value.length === 0;
     }
-    if (field.type === 'obj') {
-        return {
-            '': await (0, parse_1.parseObj)(field, value, field.array, trx, parseFields)
-        };
+    if (typeof value === 'object') {
+        return Object.keys(value).length === 0;
     }
-    if (field.type === 'dict') {
-        return {
-            '': await (0, parse_1.parseDict)(field, value, field.array, trx, parseFields)
-        };
+    if (typeof value === 'string') {
+        return value.length === 0;
     }
-    throw error_1.NesoiError.Builder.Message.UnknownTemplateFieldType(field.type);
+    return false;
 }

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

@@ -169,6 +169,7 @@ export declare namespace NesoiError {
             module: string;
         }): BaseError;
         function InvalidEnumScope($: {
+            path: string;
             name: string;
             alias?: string;
             value: any;
@@ -176,15 +177,23 @@ export declare namespace NesoiError {
         }): BaseError;
         function InvalidFieldEnumValue($: {
             field: string;
+            path: string;
             value: any;
             type: string;
             options: string[];
         }): BaseError;
         function InvalidFieldType($: {
             field: string;
+            path: string;
             value: any;
             type: string;
         }): BaseError;
+        function ValueDoesntMatchUnion($: {
+            field: string;
+            path: string;
+            value: any;
+            unionErrors: string[];
+        }): BaseError;
         function UnsanitaryValue($: {
             details: string;
         }): BaseError;
@@ -198,11 +207,13 @@ export declare namespace NesoiError {
             error: string;
         }): BaseError;
         function FileTooBig($: {
+            path: string;
             name: string;
             alias?: string;
             maxsize: number;
         }): BaseError;
         function FileExtNotAllowed($: {
+            path: string;
             name: string;
             alias?: string;
             options: string[];

package/lib/engine/data/error.js

@@ -313,6 +313,10 @@ var NesoiError;
             return new BaseError('Message.InvalidFieldType', `Message field '${$.field}' 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, $);
+        }
+        Message.ValueDoesntMatchUnion = ValueDoesntMatchUnion;
         function UnsanitaryValue($) {
             return new BaseError('Message.UnsanitaryValue', $.details, Status.BAD_REQUEST, $);
         }

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

@@ -1,5 +1,5 @@
 import { NesoiDate } from '../data/date';
-import { $MessageTemplateFields } from '../../elements/entities/message/template/message_template.schema';
+import { $MessageTemplateField, $MessageTemplateFields } from '../../elements/entities/message/template/message_template.schema';
 import { $Module, BucketName, ViewName } from "../../schema";
 import { AnyTrxNode } from '../transaction/trx_node';
 import { NesoiDecimal } from '../data/decimal';
@@ -7,63 +7,74 @@ import { NesoiDatetime } from '../data/datetime';
 import { NesoiFile } from '../data/file';
 import { NesoiDuration } from '../data/duration';
 export declare function parseBoolean(field: {
-    name: string;
+    path_raw: string;
     alias: string;
-}, value: any, array: boolean): Promise<boolean | boolean[]>;
+}, value: any): boolean;
 export declare function parseDate(field: {
-    name: string;
+    path_raw: string;
     alias: string;
-}, value: any, array: boolean): Promise<NesoiDate | NesoiDate[]>;
+}, value: any): NesoiDate;
 export declare function parseDatetime(field: {
-    name: string;
+    path_raw: string;
     alias: string;
-}, value: any, array: boolean): Promise<NesoiDatetime | NesoiDatetime[]>;
+}, value: any): NesoiDatetime;
 export declare function parseDuration(field: {
-    name: string;
+    path_raw: string;
     alias: string;
-}, value: any, array: boolean): Promise<NesoiDuration | NesoiDuration[]>;
+}, value: any): NesoiDuration;
 export declare function parseDecimal(field: {
-    name: string;
+    path_raw: string;
     alias: string;
-}, value: any, array: boolean): Promise<NesoiDecimal | NesoiDecimal[]>;
+}, value: any): NesoiDecimal;
 export declare function parseEnum(raw: Record<string, any>, field: {
+    path_raw: string;
     name: string;
     alias: string;
-}, value: any, array: boolean, options: string | readonly string[] | Record<string, any>, trx: AnyTrxNode): Promise<any>;
+}, value: any, options: string | readonly string[] | Record<string, any>, trx: AnyTrxNode): any;
 export declare function parseFile(field: {
+    path_raw: string;
     name: string;
     alias: string;
-}, value: any, array: boolean, options?: {
+}, value: any, options?: {
     maxsize?: number;
     extnames?: string[];
-}): Promise<NesoiFile | NesoiFile[]>;
+}): NesoiFile;
 export declare function parseFloat_(field: {
-    name: string;
+    path_raw: string;
     alias: string;
-}, value: any, array: boolean): Promise<number | number[]>;
+}, value: any): number;
 export declare function parseId<M extends $Module, Name extends BucketName<M>, View extends ViewName<M['buckets'][Name]> | undefined>(field: {
-    name: string;
+    path_raw: string;
     alias: string;
-}, value: any, array: boolean, trx: AnyTrxNode, bucket: Name, type?: 'int' | 'string', view?: View): Promise<unknown>;
+}, value: any, trx: AnyTrxNode, bucket: Name, type?: 'int' | 'string', view?: View): Promise<{
+    id: string | number;
+    obj: any;
+}>;
 export declare function parseInt_(field: {
-    name: string;
+    path_raw: string;
     alias: string;
-}, value: any, array: boolean): Promise<number | number[]>;
+}, value: any): number;
 export declare function parseString(field: {
-    name: string;
+    path_raw: string;
     alias: string;
-}, value: any, array: boolean): Promise<string | string[]>;
+}, value: any): string;
 export declare function parseStringOrNumber(field: {
-    name: string;
+    path_raw: string;
     alias: string;
-}, value: any, array: boolean): Promise<string | number | (string | number)[]>;
+}, value: any): string | number;
 export declare function parseDict(field: {
-    name: string;
+    path_raw: string;
     alias: string;
     children?: $MessageTemplateFields;
-}, value: any, array: boolean, trx: AnyTrxNode, parseFields: (trx: AnyTrxNode, fields: $MessageTemplateFields, obj: Record<string, any>) => Promise<Record<string, any>>): Promise<unknown>;
+}, value: any): Record<string, {
+    field: $MessageTemplateField;
+    value?: any;
+}>;
 export declare function parseObj(field: {
-    name: string;
+    path_raw: string;
     alias: string;
     children?: $MessageTemplateFields;
-}, value: any, array: boolean, trx: AnyTrxNode, parseFields: (trx: AnyTrxNode, fields: $MessageTemplateFields, obj: Record<string, any>) => Promise<Record<string, any>>): Promise<unknown>;
+}, value: any, path_idx: number): Record<string, {
+    field: $MessageTemplateField;
+    value?: any;
+}>;