nesoi 3.0.20 → 3.1.0

package/lib/engine/data/tree.js

@@ -17,6 +17,8 @@ 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, fieldpath, index = '*') {
         index = (!Array.isArray(index)) ? index : [...index];
@@ -90,6 +92,40 @@ class Tree {
         }
         return ref;
     }
+    static getModelpath(obj, modelpath, index) {
+        const paths = modelpath.split('.');
+        let poll = [obj];
+        while (poll.length) {
+            const next = [];
+            for (const item of poll) {
+                const path = paths[item.i];
+                // '*'
+                if (path === '*') {
+                    if (typeof item !== 'object') {
+                        throw new Error(`Can't read *, item is not object (${item})`);
+                    }
+                    next.push(...Object.values(item));
+                }
+                else {
+                    const idx_str = path.match(/^\$(\d+)/)?.[1];
+                    let _path = path;
+                    // $0, $1..
+                    if (idx_str !== undefined) {
+                        const idx = parseInt(idx_str);
+                        if (idx >= index.length) {
+                            throw new Error(`Can't read $${idx}, too few indexes (${index.length})`);
+                        }
+                        _path = index[idx];
+                    }
+                    const n = typeof item === 'object' ? item[_path] : undefined;
+                    if (n)
+                        next.push(n);
+                }
+            }
+            poll = next;
+        }
+        return poll;
+    }
     static set(obj, fieldpath, replacer, __index = []) {
         const paths = fieldpath.split('.');
         class Ptr {

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

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

package/lib/engine/util/parse.js

@@ -13,6 +13,7 @@ exports.parseInt_ = parseInt_;
 exports.parseString = parseString;
 exports.parseStringOrNumber = parseStringOrNumber;
 exports.parseDict = parseDict;
+exports.parseList = parseList;
 exports.parseObj = parseObj;
 const date_1 = require("../data/date");
 const error_1 = require("../data/error");
@@ -21,7 +22,7 @@ const decimal_1 = require("../data/decimal");
 const datetime_1 = require("../data/datetime");
 const file_1 = require("../data/file");
 const duration_1 = require("../data/duration");
-function parseBoolean(field, value) {
+function parseBoolean(field, path, value) {
     if (value === 'true' || value === 1) {
         return true;
     }
@@ -31,34 +32,34 @@ function parseBoolean(field, value) {
     if (typeof value === 'boolean') {
         return value;
     }
-    throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path: field.path_raw, value, type: 'boolean' });
+    throw error_1.NesoiError.Message.InvalidFieldType({ alias: field.alias, path: path.join('.'), value, type: 'boolean' });
 }
-function parseDate(field, value) {
+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: field.path_raw, value, type: 'date' });
+    throw error_1.NesoiError.Message.InvalidFieldType({ alias: field.alias, path: path.join('.'), value, type: 'date' });
 }
-function parseDatetime(field, value) {
+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: field.path_raw, value, type: 'datetime' });
+    throw error_1.NesoiError.Message.InvalidFieldType({ alias: field.alias, path: path.join('.'), value, type: 'datetime' });
 }
-function parseDuration(field, value) {
+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: field.path_raw, value, type: 'duration' });
+    throw error_1.NesoiError.Message.InvalidFieldType({ alias: field.alias, path: path.join('.'), value, type: 'duration' });
 }
-function parseDecimal(field, value) {
+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: field.path_raw, value, type: 'decimal' });
+    throw error_1.NesoiError.Message.InvalidFieldType({ alias: field.alias, path: path.join('.'), value, type: 'decimal' });
 }
-function parseEnum(raw, field, value, options, trx) {
+function parseEnum(raw, field, path, value, options, trx) {
     if (typeof value === 'string') {
         if (typeof options === 'string') {
             let enumName = options;
@@ -71,7 +72,7 @@ function parseEnum(raw, field, value, options, trx) {
                 }
                 catch {
                     const v = tree_1.Tree.get(raw, enumPath[2]);
-                    throw error_1.NesoiError.Message.InvalidEnumScope({ path: field.path_raw, 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 +83,7 @@ function parseEnum(raw, field, value, options, trx) {
                 return value;
             }
             else {
-                throw error_1.NesoiError.Message.InvalidFieldEnumValue({ field: field.alias, path: field.path_raw, 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 +91,7 @@ function parseEnum(raw, field, value, options, trx) {
                 return value;
             }
             else {
-                throw error_1.NesoiError.Message.InvalidFieldEnumValue({ field: field.alias, path: field.path_raw, 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,34 +99,29 @@ function parseEnum(raw, field, value, options, trx) {
                 return options[value];
             }
             else {
-                throw error_1.NesoiError.Message.InvalidFieldEnumValue({ field: field.alias, path: field.path_raw, 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: field.path_raw, value, type: 'string' });
+    throw error_1.NesoiError.Message.InvalidFieldType({ alias: field.alias, path: path.join('.'), value, type: 'string' });
 }
-function parseFile(field, value, options) {
+function parseFile(field, path, value, options) {
     if (!(value instanceof file_1.NesoiFile)) {
-        throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path: field.path_raw, 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: field.path_raw,
-                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: field.path_raw, 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;
 }
-function parseFloat_(field, value) {
+function parseFloat_(field, path, value) {
     if (typeof value === 'string') {
         const val = parseFloat(value);
         if (!Number.isNaN(val)) {
@@ -137,15 +133,15 @@ function parseFloat_(field, value) {
             return value;
         }
     }
-    throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path: field.path_raw, value, type: 'float' });
+    throw error_1.NesoiError.Message.InvalidFieldType({ alias: field.alias, path: path.join('.'), value, type: 'float' });
 }
-async function parseId(field, value, trx, bucket, type, view) {
+async function parseId(field, path, value, trx, bucket, type, view) {
     let val;
     if (type === 'string') {
-        val = parseString(field, value);
+        val = parseString(field, path, value);
     }
     else {
-        val = parseInt_(field, value);
+        val = parseInt_(field, path, value);
     }
     return {
         id: val,
@@ -154,7 +150,7 @@ async function parseId(field, value, trx, bucket, type, view) {
             : await trx.bucket(bucket).readOneOrFail(val)
     };
 }
-function parseInt_(field, value) {
+function parseInt_(field, path, value) {
     if (typeof value === 'string') {
         const val = parseInt(value);
         if (!Number.isNaN(val)) {
@@ -167,25 +163,25 @@ function parseInt_(field, value) {
             return val;
         }
     }
-    throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path: field.path_raw, value, type: 'integer' });
+    throw error_1.NesoiError.Message.InvalidFieldType({ alias: field.alias, path: path.join('.'), value, type: 'integer' });
 }
-function parseString(field, value) {
+function parseString(field, path, value) {
     if (typeof value === 'string') {
         return value;
     }
-    throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path: field.path_raw, value, type: 'string' });
+    throw error_1.NesoiError.Message.InvalidFieldType({ alias: field.alias, path: path.join('.'), value, type: 'string' });
 }
-function parseStringOrNumber(field, value) {
+function parseStringOrNumber(field, path, value) {
     if (typeof value === 'string' || typeof value === 'number') {
         return value;
     }
-    throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path: field.path_raw, 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, value) {
+function parseDict(field, path, value) {
     if (typeof value === 'object') {
         const children = {};
         for (const key in value) {
-            const _field = field.children['__dict'];
+            const _field = field.children['#'];
             children[key] = {
                 field: _field,
                 value: value[key]
@@ -193,17 +189,31 @@ function parseDict(field, value) {
         }
         return children;
     }
-    throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path: field.path_raw, value, type: 'dict' });
+    throw error_1.NesoiError.Message.InvalidFieldType({ alias: field.alias, path: path.join('.'), value, type: 'dict' });
 }
-function parseObj(field, value, path_idx) {
+function parseList(field, path, value) {
+    if (!Array.isArray(value)) {
+        throw error_1.NesoiError.Message.InvalidFieldType({ alias: field.alias, path: path.join('.'), value, type: 'list' });
+    }
+    const children = {};
+    for (let i = 0; i < value.length; i++) {
+        const _field = field.children['#'];
+        children[i] = {
+            field: _field,
+            value: value[i]
+        };
+    }
+    return children;
+}
+function parseObj(field, path, value) {
     if (typeof value === 'object') {
         if (!field.children)
             return {};
         const children = {};
         for (const key in field.children) {
             const _field = field.children[key];
-            const key_raw = _field.path_raw.split('.')[path_idx + 1];
-            const key_parsed = _field.path_parsed.split('.')[path_idx + 1];
+            const key_raw = _field.pathRaw.split('.')[path.length];
+            const key_parsed = _field.pathParsed.split('.')[path.length];
             children[key_parsed] = {
                 field: _field,
                 value: value[key_raw]
@@ -211,5 +221,5 @@ function parseObj(field, value, path_idx) {
         }
         return children;
     }
-    throw error_1.NesoiError.Message.InvalidFieldType({ field: field.alias, path: field.path_raw, value, type: 'object' });
+    throw error_1.NesoiError.Message.InvalidFieldType({ alias: field.alias, path: path.join('.'), value, type: 'object' });
 }

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

@@ -5,3 +5,6 @@ export type MergeUnion<T> = {
         [J in K]: any;
     } ? T[K] : never;
 };
+export type UnionToIntersection<T> = {
+    [K in T as K & string]: K;
+}[any];

package/package.json

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

package/tools/joaquin/bucket.d.ts

@@ -0,0 +1,9 @@
+import { AnyBucketBuilder } from "../../src/elements/entities/bucket/bucket.builder";
+import { NesoiError } from "../../src/engine/data/error";
+import { AnyBuilder } from "../../src/engine/module";
+export declare function expectBucket(def: (builder: AnyBucketBuilder) => any, inject?: AnyBuilder[]): {
+    toBuildOne(raw: Record<string, any>, view: string): {
+        as(parsed: Record<string, any>): Promise<void>;
+        butFail(error: (...args: any[]) => NesoiError.BaseError): Promise<void>;
+    };
+};

package/tools/joaquin/bucket.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expectBucket = expectBucket;
+const bucket_builder_1 = require("../../src/elements/entities/bucket/bucket.builder");
+const inline_app_1 = require("../../src/engine/apps/inline.app");
+function expectBucket(def, inject = []) {
+    const builder = new bucket_builder_1.BucketBuilder('test', 'test');
+    def(builder);
+    const app = new inline_app_1.InlineApp('test', [...inject, builder]);
+    let promise;
+    const step1 = {
+        toBuildOne(raw, view) {
+            promise = Promise.all([raw].map(raw => app.daemon().then(daemon => daemon.trx('test').run(trx => trx.bucket('test').buildOne(raw, view)))));
+            return step2;
+        }
+    };
+    const step2 = {
+        async as(parsed) {
+            const status = await promise;
+            status.forEach(st => {
+                if (st.state === 'error') {
+                    console.log(st.summary());
+                    console.error(st.error?.data);
+                    console.error(st.error?.data?.unionErrors);
+                    console.error(st.error?.stack);
+                }
+                expect(st.state).toEqual('ok');
+                expect(st.output)
+                    .toEqual(parsed);
+            });
+        },
+        async butFail(error) {
+            const errorObj = error({});
+            try {
+                const status = await promise;
+                status.forEach(st => {
+                    expect(st.state).toEqual('error');
+                    expect(st.error?.name)
+                        .toEqual(errorObj.name);
+                });
+            }
+            catch (e) {
+                expect(e.toString())
+                    .toMatch(new RegExp(`^\\[${errorObj.name}\\]`));
+            }
+        }
+    };
+    return step1;
+}

package/tools/joaquin/message.d.ts

@@ -1,6 +1,7 @@
 import { MessageTemplateDef } from "../../src/elements/entities/message/template/message_template.builder";
 import { NesoiError } from "../../src/engine/data/error";
-export declare function expectMessage(def: MessageTemplateDef<any, any, any>): {
+import { AnyBuilder } from "../../src/engine/module";
+export declare function expectMessage(def: MessageTemplateDef<any, any, any>, inject?: AnyBuilder[]): {
     toParse(raw: Record<string, any>): {
         as(parsed: Record<string, any>): Promise<void>;
         butFail(error: (...args: any[]) => NesoiError.BaseError): Promise<void>;

package/tools/joaquin/message.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.expectMessage = expectMessage;
 const message_builder_1 = require("../../src/elements/entities/message/message.builder");
 const inline_app_1 = require("../../src/engine/apps/inline.app");
-function expectMessage(def) {
+function expectMessage(def, inject = []) {
     const builder = new message_builder_1.MessageBuilder('test', 'test');
     builder.template(def);
-    const app = new inline_app_1.InlineApp('test', [builder]);
+    const app = new inline_app_1.InlineApp('test', [...inject, builder]);
     let promise;
     const step1 = {
         toParse(raw) {
@@ -22,6 +22,13 @@ function expectMessage(def) {
         async as(parsed) {
             const status = await promise;
             status.forEach(st => {
+                if (st.state === 'error') {
+                    console.log(st.summary());
+                    console.error(st.error?.message);
+                    console.error(st.error?.data);
+                    console.error(st.error?.data?.unionErrors);
+                    console.error(st.error?.stack);
+                }
                 expect(st.state).toEqual('ok');
                 expect(st.output.getData())
                     .toEqual(parsed);

package/tools/joaquin/mock.d.ts

@@ -15,6 +15,7 @@ export declare class BucketMockObj<$ extends $Bucket, T> {
     view(daemon: Daemon<any, any>, view: keyof $['views']): Promise<T>;
     private bindBucket;
     private makeObj;
+    private makeUnion;
     private makeList;
     private makeField;
 }

package/tools/joaquin/mock.js

@@ -40,7 +40,10 @@ class BucketMockObj {
             }
             else {
                 const field = fields[f];
-                if (field.array) {
+                if (field.type === 'union') {
+                    obj[f] = this.makeUnion(field, overrides?.[f]);
+                }
+                if (field.type === 'list') {
                     obj[f] = this.makeList(field, overrides?.[f]);
                 }
                 else {
@@ -50,6 +53,11 @@ class BucketMockObj {
         }
         return obj;
     }
+    makeUnion(field, overrides) {
+        const n = Object.keys(field.children).length;
+        const r = Math.floor(Math.random() * n);
+        return this.makeField(field.children[r], overrides);
+    }
     makeList(field, overrides) {
         const list = [];
         for (let i = 0; i < 3; i++) {
@@ -73,7 +81,7 @@ class BucketMockObj {
         else if (field.type === 'dict') {
             const dict = {};
             for (let i = 0; i < 3; i++) {
-                dict[Mock.string()] = this.makeField(field.children.__dict);
+                dict[Mock.string()] = this.makeField(field.children['#']);
             }
             return dict;
         }
@@ -134,8 +142,8 @@ class MessageMock {
             }
             else {
                 const field = fields[f];
-                if (field.array) {
-                    obj[f] = this.makeList(field, overrides?.[f]);
+                if (field.type === 'list') {
+                    obj[f] = this.makeList(field.children['#'], overrides?.[f]);
                 }
                 else {
                     obj[f] = this.makeField(field, overrides?.[f]);
@@ -167,7 +175,7 @@ class MessageMock {
         else if (field.type === 'dict') {
             const dict = {};
             for (let i = 0; i < 3; i++) {
-                dict[Mock.string()] = this.makeField(field.children.__dict);
+                dict[Mock.string()] = this.makeField(field.children['#']);
             }
             return dict;
         }