nesoi 3.0.17 → 3.0.19

package/lib/engine/util/parse.js

@@ -21,224 +21,193 @@ const decimal_1 = require("../data/decimal");
 const datetime_1 = require("../data/datetime");
 const file_1 = require("../data/file");
 const duration_1 = require("../data/duration");
-// TODO: check the performance of this wild thing below
-async function parse(type, field, value, array, fn) {
-    if (array) {
-        if (!Array.isArray(value)) {
-            throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value, type: `${type}[]` });
-        }
-        const parsed = [];
-        for (const v in value) {
-            parsed.push(await fn(value[v]));
-        }
-        return parsed;
+function parseBoolean(field, path, value) {
+    if (value === 'true' || value === 1) {
+        return true;
     }
-    return fn(value);
-}
-function parseBoolean(field, value, array) {
-    return parse('boolean', field, value, array, (v) => {
-        if (v === 'true' || v === 1) {
-            return true;
-        }
-        if (v === 'false' || v === 0) {
-            return false;
-        }
-        if (typeof v === 'boolean') {
-            return v;
-        }
-        throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value: v, type: 'boolean' });
-    });
+    if (value === 'false' || value === 0) {
+        return false;
+    }
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path, value, type: 'boolean' });
 }
-function parseDate(field, value, array) {
-    return parse('date', field, value, array, (v) => {
-        // TODO: limit to date
-        if (typeof v === 'string') {
-            return date_1.NesoiDate.fromISO(v);
-        }
-        throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value: v, type: 'date' });
-    });
+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' });
 }
-function parseDatetime(field, value, array) {
-    return parse('datetime', field, value, array, (v) => {
-        if (typeof v === 'string') {
-            return datetime_1.NesoiDatetime.fromISO(v);
-        }
-        throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value: v, type: 'datetime' });
-    });
+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' });
 }
-function parseDuration(field, value, array) {
-    return parse('duration', field, value, array, (v) => {
-        if (typeof v === 'string') {
-            return duration_1.NesoiDuration.fromString(v);
-        }
-        throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value: v, type: 'duration' });
-    });
+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' });
 }
-function parseDecimal(field, value, array) {
-    return parse('decimal', field, value, array, (v) => {
-        if (typeof v === 'string') {
-            return new decimal_1.NesoiDecimal(v);
-        }
-        throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value: v, type: 'decimal' });
-    });
+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' });
 }
-function parseEnum(raw, field, value, array, options, trx) {
-    return parse('enum', field, value, array, (v) => {
-        if (typeof v === 'string') {
-            if (typeof options === 'string') {
-                let enumName = options;
-                const enumPath = enumName.match(/(.*)\.\{(.*)\}$/);
-                let _enum;
-                if (enumPath) {
-                    enumName += enumPath[1] + '.' + enumPath[2];
-                    try {
-                        _enum = trx.enum(enumName);
-                    }
-                    catch {
-                        const v = tree_1.Tree.get(raw, enumPath[2]);
-                        throw error_1.NesoiError.Message.InvalidEnumScope({ name: field.name, alias: field.alias, value: v, fieldpath: enumPath[2] });
-                    }
-                }
-                else {
+function parseEnum(raw, field, path, value, options, trx) {
+    if (typeof value === 'string') {
+        if (typeof options === 'string') {
+            let enumName = options;
+            const enumPath = enumName.match(/(.*)\.\{(.*)\}$/);
+            let _enum;
+            if (enumPath) {
+                enumName += enumPath[1] + '.' + enumPath[2];
+                try {
                     _enum = trx.enum(enumName);
                 }
-                const keys = _enum.keys();
-                if (keys.includes(v)) {
-                    return v;
-                }
-                else {
-                    throw error_1.NesoiError.Message.InvalidFieldEnumValue({ field: field.alias, value: v, type: 'enum', options: keys });
+                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] });
                 }
             }
-            else if (Array.isArray(options)) {
-                if (options.includes(v)) {
-                    return v;
-                }
-                else {
-                    throw error_1.NesoiError.Message.InvalidFieldEnumValue({ field: field.alias, value: v, type: 'enum', options });
-                }
+            else {
+                _enum = trx.enum(enumName);
             }
-            else if (typeof options === 'object') {
-                if (v in options) {
-                    return options[v];
-                }
-                else {
-                    throw error_1.NesoiError.Message.InvalidFieldEnumValue({ field: field.alias, value: v, type: 'enum', options: Object.keys(options) });
-                }
+            const keys = _enum.keys();
+            if (keys.includes(value)) {
+                return value;
+            }
+            else {
+                throw error_1.NesoiError.Message.InvalidFieldEnumValue({ field: field.alias, path, value, type: 'enum', options: keys });
             }
         }
-        throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value: v, type: 'string' });
-    });
-}
-function parseFile(field, value, array, options) {
-    return parse('file', field, value, array, (v) => {
-        if (!(v instanceof file_1.NesoiFile)) {
-            throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value: v, type: 'file' });
-        }
-        if (options?.maxsize) {
-            if (v.size > options?.maxsize) {
-                throw error_1.NesoiError.Message.FileTooBig({
-                    name: field.name,
-                    alias: field.alias,
-                    maxsize: options?.maxsize
-                });
+        else if (Array.isArray(options)) {
+            if (options.includes(value)) {
+                return value;
+            }
+            else {
+                throw error_1.NesoiError.Message.InvalidFieldEnumValue({ field: field.alias, path, value, type: 'enum', options });
             }
         }
-        if (options?.extnames) {
-            if (!options?.extnames.includes(v.extname)) {
-                throw error_1.NesoiError.Message.FileExtNotAllowed({ name: field.name, alias: field.alias, options: options?.extnames });
+        else if (typeof options === 'object') {
+            if (value in options) {
+                return options[value];
+            }
+            else {
+                throw error_1.NesoiError.Message.InvalidFieldEnumValue({ field: field.alias, path, value, type: 'enum', options: Object.keys(options) });
             }
         }
-        return v;
-    });
+    }
+    throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path, value, type: 'string' });
 }
-function parseFloat_(field, value, array) {
-    return parse('float', field, value, array, (v) => {
-        if (typeof v === 'string') {
-            const val = parseFloat(v);
-            if (!Number.isNaN(val)) {
-                return val;
-            }
+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' });
+    }
+    if (options?.maxsize) {
+        if (value.size > options?.maxsize) {
+            throw error_1.NesoiError.Message.FileTooBig({
+                path,
+                name: field.name,
+                alias: field.alias,
+                maxsize: options?.maxsize
+            });
         }
-        else if (typeof v === 'number') {
-            if (!Number.isNaN(v)) {
-                return v;
-            }
+    }
+    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.InvalidFieldType({ field: field.alias, value: v, type: 'float' });
-    });
+    }
+    return value;
 }
-async function parseId(field, value, array, trx, bucket, type, view) {
-    return parse('id', field, value, array, (async (v) => {
-        let val;
-        if (type === 'string') {
-            val = await parseString(field, value, array);
+function parseFloat_(field, path, value) {
+    if (typeof value === 'string') {
+        const val = parseFloat(value);
+        if (!Number.isNaN(val)) {
+            return val;
         }
-        else {
-            val = await parseInt_(field, value, array);
+    }
+    else if (typeof value === 'number') {
+        if (!Number.isNaN(value)) {
+            return value;
         }
-        return {
+    }
+    throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path, value, type: 'float' });
+}
+async function parseId(field, path, value, trx, bucket, type, view) {
+    let val;
+    if (type === 'string') {
+        val = parseString(field, path, value);
+    }
+    else {
+        val = parseInt_(field, path, value);
+    }
+    return {
+        value: {
             id: val,
             obj: view
                 ? await trx.bucket(bucket).viewOneOrFail(val, view)
                 : await trx.bucket(bucket).readOneOrFail(val)
-        };
-    })); // type only required on query parsers
+        }
+    };
 }
-function parseInt_(field, value, array) {
-    return parse('int', field, value, array, (v) => {
-        if (typeof v === 'string') {
-            const val = parseInt(v);
-            if (!Number.isNaN(val)) {
-                return val;
-            }
+function parseInt_(field, path, value) {
+    if (typeof value === 'string') {
+        const val = parseInt(value);
+        if (!Number.isNaN(val)) {
+            return val;
         }
-        else if (typeof v === 'number') {
-            const val = Math.floor(v);
-            if (!Number.isNaN(val)) {
-                return val;
-            }
+    }
+    else if (typeof value === 'number') {
+        const val = Math.floor(value);
+        if (!Number.isNaN(val)) {
+            return val;
         }
-        throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value: v, type: 'integer' });
-    });
+    }
+    throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path, value, type: 'integer' });
 }
-function parseString(field, value, array) {
-    return parse('string', field, value, array, (v) => {
-        if (typeof v === 'string') {
-            return v;
-        }
-        throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value: v, type: 'string' });
-    });
+function parseString(field, path, value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path, value, type: 'string' });
 }
-function parseStringOrNumber(field, value, array) {
-    return parse('string_or_number', field, value, array, (v) => {
-        if (typeof v === 'string' || typeof v === 'number') {
-            return v;
-        }
-        throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value: v, type: 'string_or_number' });
-    });
+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' });
 }
-async function parseDict(field, value, array, trx, parseFields) {
-    return parse('dict', field, value, array, (async (v) => {
-        if (typeof v === 'object') {
-            const parsed = {};
-            for (const k in v) {
-                const pv = await parseFields(trx, field.children, { __dict: v[k] });
-                parsed[k] = pv['__dict'];
-            }
-            return parsed;
-        }
-        throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value: v, type: 'dict' });
-    }));
+function parseDict(field, path, value) {
+    if (typeof value === 'object') {
+        const children = {};
+        for (const key in value) {
+            children[key] = {
+                field: field.children['__dict'],
+                value: value[key]
+            };
+        }
+        return children;
+    }
+    throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path, value, type: 'dict' });
 }
-async function parseObj(field, value, array, trx, parseFields) {
-    return parse('obj', field, value, array, (async (v) => {
-        if (typeof v === 'object') {
-            if (field.children) {
-                return await parseFields(trx, field.children, v);
-            }
-            return v;
-        }
-        throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, value: v, type: 'object' });
-    }));
+function parseObj(field, path, value) {
+    if (typeof value === 'object') {
+        if (!field.children)
+            return {};
+        const children = {};
+        for (const key in field.children) {
+            children[key] = {
+                field: field.children[key],
+                value: value[key]
+            };
+        }
+        return children;
+    }
+    throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path, value, type: 'object' });
 }

package/package.json

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