nesoi 3.0.17 → 3.0.19

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

@@ -1,89 +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, field.path_raw, raw, value);
+}
+// 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, path, raw, value) {
+    if (isEmpty(value)) {
+        if (field.required) {
+            throw error_1.NesoiError.Message.FieldIsRequired({ field: field.alias, path, 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, value, type: 'list' });
+        }
+        if (field.required && !value.length) {
+            throw error_1.NesoiError.Message.FieldIsRequired({ field: field.alias, path, value });
+        }
+        const parsedValue = [];
+        for (let i = 0; i < value.length; i++) {
+            const v = value[i];
+            const parsed = await _attemptUnion(trx, field, `${path}.${i}`, raw, v);
+            parsedValue.push(parsed);
+        }
+        return parsedValue;
     }
-    if (field.type === 'datetime') {
-        return {
-            '': await (0, parse_1.parseDatetime)(field, value, field.array)
-        };
+    return _attemptUnion(trx, field, path, raw, value);
+}
+async function _attemptUnion(trx, field, path, raw, value, unionErrors = []) {
+    try {
+        return await _runParseMethod(trx, field, path, raw, value);
     }
-    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, path, raw, value, [...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, 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, path, raw, value) {
+    switch (field.type) {
+        case 'obj':
+        case 'dict':
+            return await parseParentField(trx, field, path, raw, value);
+        case 'unknown':
+            return value;
+        case 'boolean':
+            return (0, parse_1.parseBoolean)(field, path, value);
+        case 'date':
+            return (0, parse_1.parseDate)(field, path, value);
+        case 'datetime':
+            return (0, parse_1.parseDatetime)(field, path, value);
+        case 'duration':
+            return (0, parse_1.parseDuration)(field, path, value);
+        case 'decimal':
+            return (0, parse_1.parseDecimal)(field, path, value);
+        case 'enum':
+            return (0, parse_1.parseEnum)(raw, field, path, value, field.meta.enum.options, trx);
+        case 'file':
+            return (0, parse_1.parseFile)(field, path, value, field.meta.file);
+        case 'float':
+            return (0, parse_1.parseFloat_)(field, path, value);
+        case 'int':
+            return (0, parse_1.parseInt_)(field, path, value);
+        case 'string':
+            return (0, parse_1.parseString)(field, path, value);
+        case 'string_or_number':
+            return (0, parse_1.parseStringOrNumber)(field, path, value);
+        case 'id':
+            return await parseIdField(trx, field, path, 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, path, raw, value) {
+    let children;
+    if (field.type === 'obj') {
+        children = (0, parse_1.parseObj)(field, path, value);
     }
-    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, path, 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, `${path}.${key}`, raw, child.value);
     }
-    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);
-        return {
-            '': parsed.obj
-        };
+    return parsed;
+}
+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, path, 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/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,64 @@ import { NesoiDatetime } from '../data/datetime';
 import { NesoiFile } from '../data/file';
 import { NesoiDuration } from '../data/duration';
 export declare function parseBoolean(field: {
-    name: string;
     alias: string;
-}, value: any, array: boolean): Promise<boolean | boolean[]>;
+}, path: string, value: any): boolean;
 export declare function parseDate(field: {
-    name: string;
     alias: string;
-}, value: any, array: boolean): Promise<NesoiDate | NesoiDate[]>;
+}, path: string, value: any): NesoiDate;
 export declare function parseDatetime(field: {
-    name: string;
     alias: string;
-}, value: any, array: boolean): Promise<NesoiDatetime | NesoiDatetime[]>;
+}, path: string, value: any): NesoiDatetime;
 export declare function parseDuration(field: {
-    name: string;
     alias: string;
-}, value: any, array: boolean): Promise<NesoiDuration | NesoiDuration[]>;
+}, path: string, value: any): NesoiDuration;
 export declare function parseDecimal(field: {
-    name: string;
     alias: string;
-}, value: any, array: boolean): Promise<NesoiDecimal | NesoiDecimal[]>;
+}, path: string, value: any): NesoiDecimal;
 export declare function parseEnum(raw: Record<string, any>, field: {
     name: string;
     alias: string;
-}, value: any, array: boolean, options: string | readonly string[] | Record<string, any>, trx: AnyTrxNode): Promise<any>;
+}, path: string, value: any, options: string | readonly string[] | Record<string, any>, trx: AnyTrxNode): any;
 export declare function parseFile(field: {
     name: string;
     alias: string;
-}, value: any, array: boolean, options?: {
+}, path: string, value: any, options?: {
     maxsize?: number;
     extnames?: string[];
-}): Promise<NesoiFile | NesoiFile[]>;
+}): NesoiFile;
 export declare function parseFloat_(field: {
-    name: string;
     alias: string;
-}, value: any, array: boolean): Promise<number | 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: {
-    name: string;
     alias: string;
-}, value: any, array: boolean, trx: AnyTrxNode, bucket: Name, type?: 'int' | 'string', view?: View): Promise<unknown>;
+}, path: string, value: any, trx: AnyTrxNode, bucket: Name, type?: 'int' | 'string', view?: View): Promise<{
+    value: {
+        id: string | number;
+        obj: any;
+    };
+}>;
 export declare function parseInt_(field: {
-    name: string;
     alias: string;
-}, value: any, array: boolean): Promise<number | number[]>;
+}, path: string, value: any): number;
 export declare function parseString(field: {
-    name: string;
     alias: string;
-}, value: any, array: boolean): Promise<string | string[]>;
+}, path: string, value: any): string;
 export declare function parseStringOrNumber(field: {
-    name: string;
     alias: string;
-}, value: any, array: boolean): Promise<string | number | (string | number)[]>;
+}, path: string, 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>;
+}, path: string, 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>;
+}, path: string, value: any): Record<string, {
+    field: $MessageTemplateField;
+    value?: any;
+}>;