nesoi 3.0.21 → 3.1.1

package/lib/compiler/apps/monolyth/stages/2_build_typescript_stage.js

@@ -88,6 +88,7 @@ class BuildTypescriptStage {
         }
         libPaths.forEach(lib => {
             lib = space_1.Space.relPath(compiler.space, lib);
+            // TODO: flatten sub-directory of modules
             replacePaths[lib] = path.resolve(dirs.build, lib);
             tsPaths['.nesoi/*'] = [space_1.Space.path(compiler.space, '.nesoi') + '/*'];
             tsPaths[lib + '/*'] = [space_1.Space.path(compiler.space, lib) + '/*'];

package/lib/compiler/apps/monolyth/stages/4_dump_modules_stage.js

@@ -75,6 +75,14 @@ class DumpModulesStage {
                 }
                 str += '\n      },';
             }
+            if (Object.keys(externals.messages).length) {
+                str += '\n      messages: {';
+                for (const b in externals.messages) {
+                    const dep = externals.messages[b];
+                    str += `\n        '${b}': ${JSON.stringify(dep, undefined, 2).replace(/\n/g, '\n        ')},`;
+                }
+                str += '\n      },';
+            }
             if (Object.keys(externals.jobs).length) {
                 str += '\n      jobs: {\n';
                 for (const b in externals.jobs) {

package/lib/compiler/compiler.js

@@ -14,9 +14,9 @@ const _4_build_schemas_stage_1 = require("./stages/4_build_schemas_stage");
 const _5_inject_ts_stage_1 = require("./stages/5_inject_ts_stage");
 const _6_build_elements_stage_1 = require("./stages/6_build_elements_stage");
 const _7_dump_stage_1 = require("./stages/7_dump_stage");
+const _8_diagnose_stage_1 = require("./stages/8_diagnose_stage");
 const console_1 = __importDefault(require("../engine/util/console"));
 const log_1 = require("../engine/util/log");
-const _8_diagnose_stage_1 = require("./stages/8_diagnose_stage");
 const fs_1 = __importDefault(require("fs"));
 class Compiler {
     constructor(space, config) {

package/lib/compiler/elements/bucket.element.d.ts

@@ -13,8 +13,9 @@ export declare class BucketElement extends Element<$Bucket> {
     };
     private buildModelFieldType;
     private buildCompositionType;
-    buildModelType(fields?: $BucketModelFields): ObjTypeAsObj;
-    buildModelFieldNamesType(model: ObjTypeAsObj, fields?: $BucketModelFields): Record<string, TypeAsObj>;
+    buildModelType(fields?: $BucketModelFields, singleLine?: boolean): ObjTypeAsObj;
+    buildModelpath(): Record<string, TypeAsObj>;
+    buildQuerypath(fields?: $BucketModelFields): Record<string, TypeAsObj>;
     private buildGraphType;
     private buildViewsType;
     private buildViewType;

package/lib/compiler/elements/bucket.element.js

@@ -1,16 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BucketElement = void 0;
+const bucket_model_schema_1 = require("../../elements/entities/bucket/model/bucket_model.schema");
 const element_1 = require("./element");
 const name_helpers_1 = require("../helpers/name_helpers");
 const dependency_1 = require("../../engine/dependency");
-const tree_1 = require("../../engine/data/tree");
 const dump_helpers_1 = require("../helpers/dump_helpers");
 class BucketElement extends element_1.Element {
     // Prepare
     prepare() {
         this.schema['#data'] = element_1.Element.Any;
-        this.schema['#fieldpath'] = element_1.Element.Any;
+        this.schema['#modelpath'] = element_1.Element.Any;
+        this.schema['#querypath'] = element_1.Element.Any;
         this.schema['#composition'] = element_1.Element.Any;
         this.schema['#defaults'] = element_1.Element.Any;
         this.prepareGraph(this.schema.graph.links);
@@ -34,9 +35,6 @@ class BucketElement extends element_1.Element {
             if (field.children) {
                 this.prepareViewFields(field.children);
             }
-            else {
-                field.children = element_1.Element.Never;
-            }
         });
     }
     // Imports 
@@ -48,13 +46,16 @@ class BucketElement extends element_1.Element {
     buildType() {
         const model = this.buildModelType();
         const bucket = dump_helpers_1.DumpHelpers.dumpValueToType(this.schema, {
+            model: () => 'any', // = this.buildModelType(),
             graph: () => this.buildGraphType(),
-            views: () => this.buildViewsType(model)
+            views: () => this.buildViewsType()
         });
-        const fieldpaths = this.buildModelFieldNamesType(model);
+        const modelpath = this.buildModelpath();
+        const querypath = this.buildQuerypath();
         const composition = this.buildCompositionType();
         Object.assign(bucket, {
-            '#fieldpath': fieldpaths,
+            '#modelpath': modelpath,
+            '#querypath': querypath,
             '#composition': composition,
             '#defaults': bucket.defaults || '{}',
             '#data': this.highName
@@ -64,7 +65,7 @@ class BucketElement extends element_1.Element {
             bucket
         };
     }
-    buildModelFieldType(field, isUnion = false) {
+    buildModelFieldType(field, singleLine = false) {
         let type = 'unknown';
         if (field.type === 'boolean') {
             type = 'boolean';
@@ -90,10 +91,10 @@ class BucketElement extends element_1.Element {
                 }
             }
             else if (Array.isArray(options)) {
-                type = options.map(v => dump_helpers_1.DumpHelpers.dumpValueToType(v));
+                type = options.map(v => dump_helpers_1.DumpHelpers.dumpValueToType(v, undefined, singleLine));
             }
             else if (typeof options === 'object') {
-                type = Object.values(options || []).map(v => dump_helpers_1.DumpHelpers.dumpValueToType(v));
+                type = Object.values(options || []).map(v => dump_helpers_1.DumpHelpers.dumpValueToType(v, undefined, singleLine));
             }
         }
         else if (field.type === 'file') {
@@ -109,47 +110,34 @@ class BucketElement extends element_1.Element {
             type = 'string';
         }
         else if (field.type === 'obj') {
-            type = this.buildModelType(field.children);
+            type = this.buildModelType(field.children, singleLine);
         }
         else if (field.type === 'unknown') {
             type = 'unknown';
         }
         else if (field.type === 'dict') {
             type = this.buildModelType({
-                '[x in string]': field.children.__dict
-            });
+                '[x in string]': field.children['#']
+            }, singleLine);
         }
-        if (field.or) {
-            const orType = this.buildModelFieldType(field.or, true);
+        else if (field.type === 'list') {
+            type = this.buildModelFieldType(field.children['#']);
             if (typeof type === 'object') {
-                type.__or = orType;
-            }
-            else if (typeof orType === 'object') {
-                const nonObj = type;
-                type = orType;
-                type.__or = nonObj;
+                type.__array = true;
             }
             else {
-                type = `${type} | ${orType}`;
+                type = `(${type})[]`;
             }
         }
-        if (!isUnion) {
-            if (!field.required && field.defaultValue === undefined) {
-                if (typeof type === 'object') {
-                    type.__optional = true;
-                }
-                else {
-                    type = `(${type}) | undefined`;
-                }
-            }
-            if (field.array) {
-                if (typeof type === 'object') {
-                    type.__array = true;
-                }
-                else {
-                    type = `(${type})[]`;
-                }
-            }
+        else if (field.type === 'union') {
+            const types = Object.values(this.buildModelType(field.children, singleLine));
+            type = dump_helpers_1.DumpHelpers.dumpUnionType(types, singleLine);
+        }
+        if (!field.required) {
+            type = '('
+                + dump_helpers_1.DumpHelpers.dumpType(type, singleLine)
+                + ' | null | undefined'
+                + ')';
         }
         return type;
     }
@@ -167,31 +155,32 @@ class BucketElement extends element_1.Element {
         });
         return composition;
     }
-    buildModelType(fields = this.schema.model.fields) {
+    buildModelType(fields = this.schema.model.fields, singleLine = false) {
         const model = {};
         Object.entries(fields).forEach(([key, field]) => {
-            model[key] = this.buildModelFieldType(field);
+            model[key] = this.buildModelFieldType(field, singleLine);
         });
         return model;
     }
-    buildModelFieldNamesType(model, fields = this.schema.model.fields) {
-        const fieldPaths = {};
-        Object.entries(fields).forEach(([key, field]) => {
-            if (key === '__dict') {
-                return;
-            }
-            fieldPaths[field.path] = model[key];
-            if (field.children) {
-                let nextFields = field.children;
-                if ('__dict' in field.children) {
-                    nextFields = field.children.__dict.children;
-                }
-                if (nextFields) {
-                    Object.assign(fieldPaths, this.buildModelFieldNamesType(model[key], nextFields));
-                }
-            }
-        });
-        return fieldPaths;
+    buildModelpath() {
+        const modelpath = {
+            '[x: string]': 'any'
+        };
+        // const fields = $BucketModel.getModelpaths(this.schema.model);
+        // console.log({fields});
+        // for (const k in fields) {
+        //     modelpath[k] = DumpHelpers.dumpUnionType(
+        //         fields[k].map(field => this.buildModelFieldType(field, true))
+        //         , true)
+        //     console.log(k, modelpath[k]);
+        // }
+        return modelpath;
+    }
+    buildQuerypath(fields = this.schema.model.fields) {
+        const querypath = {
+            '[x: string]': 'any'
+        };
+        return querypath;
     }
     buildGraphType() {
         const links = {};
@@ -208,90 +197,59 @@ class BucketElement extends element_1.Element {
             links
         };
     }
-    buildViewsType(model) {
+    buildViewsType() {
         const views = {};
         Object.entries(this.schema.views).forEach(([key, view]) => {
-            views[key] = this.buildViewType(model, view.fields, key);
+            views[key] = this.buildViewType(view.fields, key);
         });
         return views;
     }
-    buildViewType(model, schema, name) {
+    buildViewType(schema, name) {
         if (!schema) {
             return;
         }
-        const fields = {};
-        const data = {};
-        Object.entries(schema).forEach(([key, field]) => {
-            if (field.scope === 'model' && 'model' in field.value) {
-                data[key] = tree_1.Tree.get(model, field.value.model.key, 0) || {};
-                let children;
-                if (field.type === 'obj') {
-                    children = field.children &&
-                        this.buildViewType(model, field.children, field.name);
-                    data[key] = Object.assign({}, data[key], children?.['#data']);
+        const buildFields = (fields) => {
+            const data = {};
+            for (const key in fields) {
+                const field = fields[key];
+                if (field.scope === 'model' && 'model' in field.meta) {
+                    const modelFields = bucket_model_schema_1.$BucketModel.getField(this.schema.model, field.meta.model.path);
+                    const types = [];
+                    if (!field.children || '__raw' in field.children) {
+                        types.push(dump_helpers_1.DumpHelpers.dumpUnionType(modelFields.map(f => this.buildModelFieldType(f))));
+                    }
+                    // Contains children
+                    if (field.children) {
+                        types.push(buildFields(field.children));
+                    }
+                    data[key] = dump_helpers_1.DumpHelpers.dumpIntersectionType(types);
                 }
-                fields[key] = {
-                    '#data': data[key],
-                    children: children?.fields
-                };
-            }
-            else if (field.scope === 'graph' && 'graph' in field.value) {
-                const link = this.schema.graph.links[field.value.graph.link];
-                const bucket = dependency_1.$Dependency.typeName(link.bucket, this.module);
-                if (field.value.graph.view) {
-                    data[key] = `${bucket}['views']['${field.value.graph.view}']['#data']${link.many ? '[]' : ''}${link.optional ? ' | undefined' : ''}`;
+                else if (field.scope === 'graph' && 'graph' in field.meta) {
+                    const link = this.schema.graph.links[field.meta.graph.link];
+                    const bucket = dependency_1.$Dependency.typeName(link.bucket, this.module);
+                    if (field.meta.graph.view) {
+                        data[key] = `${bucket}['views']['${field.meta.graph.view}']['#data']${link.many ? '[]' : ''}${link.optional ? ' | undefined' : ''}`;
+                    }
+                    else {
+                        data[key] = `${bucket}['#data']${link.many ? '[]' : ''}${link.optional ? ' | undefined' : ''}`;
+                    }
                 }
-                else {
-                    data[key] = `${bucket}['#data']${link.many ? '[]' : ''}${link.optional ? ' | undefined' : ''}`;
+                else if (field.scope === 'computed') {
+                    data[key] = field['#data'];
                 }
-                fields[key] = {
-                    '#data': data[key],
-                    children: 'undefined'
-                };
-            }
-            else if (field.scope === 'computed') {
-                data[key] = field['#data'];
-                fields[key] = {
-                    '#data': data[key],
-                    children: 'undefined'
-                };
-            }
-            else if (field.scope === 'view' || field.scope === 'group') {
-                const children = this.buildViewType(model, field.children, field.name);
-                data[key] = children['#data'];
-                fields[key] = {
-                    '#data': data[key],
-                    children: children.fields
-                };
-            }
-            else if (field.scope === 'drive') {
-                fields[key] = {
-                    '#data': 'string',
-                    children: 'undefined'
-                };
-            }
-            const { children, ...f } = field;
-            const type = dump_helpers_1.DumpHelpers.dumpValueToType(f, {
-                $t: () => dump_helpers_1.DumpHelpers.dumpValueToType('bucket.view.field'),
-                value: {
-                    model: v => ({
-                        key: dump_helpers_1.DumpHelpers.dumpValueToType(v.key),
-                        enumOptions: v.enumOptions ? dump_helpers_1.DumpHelpers.dumpValueToType(v.enumOptions) : 'undefined'
-                    }),
-                    graph: v => ({
-                        link: dump_helpers_1.DumpHelpers.dumpValueToType(v.link),
-                        view: v.view ? dump_helpers_1.DumpHelpers.dumpValueToType(v.view) : 'undefined'
-                    }),
-                    drive: v => dump_helpers_1.DumpHelpers.dumpValueToType(v)
+                else if (field.scope === 'view' || field.scope === 'group') {
+                    const children = this.buildViewType(field.children, field.name);
+                    data[key] = children['#data'];
                 }
-            });
-            Object.assign(fields[key], type);
-        });
+            }
+            return data;
+        };
+        const data = buildFields(schema);
         return {
             $t: dump_helpers_1.DumpHelpers.dumpValueToType('bucket.view'),
+            fields: 'any',
             '#data': data,
             name: dump_helpers_1.DumpHelpers.dumpValueToType(name),
-            fields: 'any' // TODO: review if this might be needed
         };
     }
     // Dump

package/lib/compiler/elements/element.js

@@ -27,7 +27,8 @@ class Element {
     }
     bridgeImports() {
         let imports = '';
-        for (const imp of this.bridge?.imports || []) {
+        const uniqueImports = new Set(this.bridge?.imports || []);
+        for (const imp of uniqueImports) {
             imports += imp + '\n';
         }
         return imports;
@@ -76,9 +77,10 @@ class Element {
             const msgName = name_helpers_1.NameHelpers.names(schema);
             return msgName.type;
         });
+        const _input = new Set(input);
         const output = schema['#output'] || this.makeOutputType(compiler, schema);
         return {
-            input: input.length ? input.join(' | ') : 'never',
+            input: _input.size ? [..._input].join(' | ') : 'never',
             output
         };
     }

package/lib/compiler/elements/externals.element.js

@@ -33,6 +33,9 @@ class ExternalsElement extends element_1.Element {
         Object.values(this.schema.buckets).forEach(ref => {
             externalModules.add(ref.module);
         });
+        Object.values(this.schema.messages).forEach(ref => {
+            externalModules.add(ref.module);
+        });
         Object.values(this.schema.jobs).forEach(ref => {
             externalModules.add(ref.module);
         });

package/lib/compiler/elements/machine.element.js

@@ -81,7 +81,7 @@ class MachineElement extends element_1.Element {
             Object.entries(stateTransitions).forEach(([msg, msgTransitions]) => {
                 type[state][msg] = [];
                 Object.values(msgTransitions).forEach(transition => {
-                    const t = dump_helpers_1.DumpHelpers.dumpValueToType(transition, undefined, 4);
+                    const t = dump_helpers_1.DumpHelpers.dumpValueToType(transition, undefined, undefined, 4);
                     Object.assign(t, {
                         '#authn': element_1.Element.makeAuthnType(transition.authn),
                         '#input': element_1.Element.makeIOType(this.compiler, transition).input,
@@ -89,7 +89,7 @@ class MachineElement extends element_1.Element {
                     });
                     type[state][msg].push(t);
                 });
-                type[state][msg] = '[' + type[state][msg].map((v) => dump_helpers_1.DumpHelpers.dumpType(v, 4)).join(', ') + ']';
+                type[state][msg] = '[' + type[state][msg].map((v) => dump_helpers_1.DumpHelpers.dumpType(v, undefined, 4)).join(', ') + ']';
             });
         });
         return type;

package/lib/compiler/elements/message.element.js

@@ -124,76 +124,54 @@ class MessageElement extends element_1.Element {
             else if (field.type === 'dict') {
                 const child = this.buildIO(field.children);
                 input[key] = {
-                    '[x in string]': child.input.__dict
+                    '[x in string]': child.input['#']
                 };
                 output[key] = {
-                    '[x in string]': child.output.__dict
+                    '[x in string]': child.output['#']
                 };
             }
-            else if (field.type === 'msg') {
-                input[key] = 'any';
-                output[key] = 'any';
-            }
-            else {
-                input[key] = 'unknown';
-                output[key] = 'unknown';
-            }
-            if (field.or) {
-                const orType = buildField(key, field.or, true);
+            else if (field.type === 'list') {
+                const child = this.buildIO(field.children);
+                input[key] = child.input['#'];
+                output[key] = child.output['#'];
                 if (typeof input[key] === 'object') {
-                    input[key].__or = orType;
-                }
-                else if (typeof orType === 'object') {
-                    const nonObj = input[key];
-                    input[key] = orType;
-                    input[key].__or = nonObj;
+                    input[key].__array = true;
                 }
                 else {
-                    input[key] = `${input[key]} | ${orType}`;
+                    input[key] = `(${input[key]})[]`;
                 }
                 if (typeof output[key] === 'object') {
-                    output[key].__or = orType;
-                }
-                else if (typeof orType === 'object') {
-                    const nonObj = output[key];
-                    output[key] = orType;
-                    output[key].__or = nonObj;
+                    output[key].__array = true;
                 }
                 else {
-                    output[key] = `${output[key]} | ${orType}`;
+                    output[key] = `(${output[key]})[]`;
                 }
             }
-            if (!isUnion) {
-                if (!field.required) {
-                    if (typeof input[key] === 'object') {
-                        input[key].__optional = true;
-                    }
-                    else {
-                        input[key] = `(${input[key]}) | undefined`;
-                    }
-                    if (field.defaultValue === undefined) {
-                        if (typeof output[key] === 'object') {
-                            output[key].__optional = true;
-                        }
-                        else {
-                            output[key] = `(${output[key]}) | undefined`;
-                        }
-                    }
-                }
-                if (field.array) {
-                    if (typeof input[key] === 'object') {
-                        input[key].__array = true;
-                    }
-                    else {
-                        input[key] = `(${input[key]})[]`;
-                    }
-                    if (typeof output[key] === 'object') {
-                        output[key].__array = true;
-                    }
-                    else {
-                        output[key] = `(${output[key]})[]`;
-                    }
-                }
+            else if (field.type === 'union') {
+                const child = this.buildIO(field.children);
+                input[key] = '(' + Object.values(child.input).map(t => dump_helpers_1.DumpHelpers.dumpType(t)).join(' | ') + ')';
+                output[key] = '(' + Object.values(child.output).map(t => dump_helpers_1.DumpHelpers.dumpType(t)).join(' | ') + ')';
+            }
+            else if (field.type === 'msg') {
+                input[key] = 'any';
+                output[key] = 'any';
+            }
+            else {
+                input[key] = 'unknown';
+                output[key] = 'unknown';
+            }
+            if (!field.required || field.nullable) {
+                const inkey = field.type === 'id' ? `${key}_id` : key;
+                input[inkey] = '('
+                    + dump_helpers_1.DumpHelpers.dumpType(input[inkey])
+                    + (!field.required ? ' | undefined' : '')
+                    + (field.nullable ? ' | null' : '')
+                    + ')';
+                output[key] = '('
+                    + dump_helpers_1.DumpHelpers.dumpType(output[key])
+                    + ((!field.required && field.defaultValue === undefined) ? ' | undefined' : '')
+                    + (field.nullable ? ' | null' : '')
+                    + ')';
             }
         };
         Object.entries(fields).forEach(([key, field]) => {

package/lib/compiler/elements/queue.element.js

@@ -6,7 +6,7 @@ const dump_helpers_1 = require("../helpers/dump_helpers");
 class QueueElement extends element_1.Element {
     prepare() {
         this.schema['#authn'] = element_1.Element.Any;
-        this.schema['#input'] = element_1.Element.Any;
+        this.schema['#input'] = element_1.Element.Never;
         this.schema['#output'] = element_1.Element.Any;
     }
     buildType() {

package/lib/compiler/helpers/dump_helpers.d.ts

@@ -3,9 +3,11 @@ type TransformTypes = {
     [x: string]: TransformTypes | ((v?: any) => TypeAsObj);
 };
 export declare class DumpHelpers {
-    static dumpType(type: TypeAsObj, d?: number): string;
-    static dumpSchema(val: any, d?: number): string;
+    static dumpUnionType(types: TypeAsObj[], singleLine?: boolean): string;
+    static dumpIntersectionType(types: TypeAsObj[], singleLine?: boolean): string;
+    static dumpType(type: TypeAsObj, singleLine?: boolean, d?: number): string;
+    static dumpSchema(val: any, singleLine?: boolean, d?: number): string;
     private static dumpFunction;
-    static dumpValueToType(value: any, transform?: TransformTypes, d?: number): TypeAsObj;
+    static dumpValueToType(value: any, transform?: TransformTypes, singleLine?: boolean, d?: number): TypeAsObj;
 }
 export {};