nesoi 3.0.21 → 3.1.0

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

@@ -14,7 +14,8 @@ export declare class BucketElement extends Element<$Bucket> {
     private buildModelFieldType;
     private buildCompositionType;
     buildModelType(fields?: $BucketModelFields): ObjTypeAsObj;
-    buildModelFieldNamesType(model: ObjTypeAsObj, fields?: $BucketModelFields): Record<string, TypeAsObj>;
+    buildModelpath(fields?: $BucketModelFields): 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) {
         let type = 'unknown';
         if (field.type === 'boolean') {
             type = 'boolean';
@@ -116,40 +117,27 @@ class BucketElement extends element_1.Element {
         }
         else if (field.type === 'dict') {
             type = this.buildModelType({
-                '[x in string]': field.children.__dict
+                '[x in string]': field.children['#']
             });
         }
-        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));
+            type = dump_helpers_1.DumpHelpers.dumpUnionType(types);
+        }
+        if (!field.required) {
+            type = '('
+                + dump_helpers_1.DumpHelpers.dumpType(type)
+                + ' | null | undefined'
+                + ')';
         }
         return type;
     }
@@ -174,24 +162,13 @@ class BucketElement extends element_1.Element {
         });
         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(fields = this.schema.model.fields) {
+        const modelpath = {};
+        return modelpath;
+    }
+    buildQuerypath(fields = this.schema.model.fields) {
+        const querypath = {};
+        return querypath;
     }
     buildGraphType() {
         const links = {};
@@ -208,90 +185,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;

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/message.element.js

@@ -124,76 +124,53 @@ 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) {
+                input[key] = '('
+                    + dump_helpers_1.DumpHelpers.dumpType(input[key])
+                    + (!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,6 +3,8 @@ type TransformTypes = {
     [x: string]: TransformTypes | ((v?: any) => TypeAsObj);
 };
 export declare class DumpHelpers {
+    static dumpUnionType(types: TypeAsObj[]): string;
+    static dumpIntersectionType(types: TypeAsObj[]): string;
     static dumpType(type: TypeAsObj, d?: number): string;
     static dumpSchema(val: any, d?: number): string;
     private static dumpFunction;

package/lib/compiler/helpers/dump_helpers.js

@@ -2,6 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DumpHelpers = void 0;
 class DumpHelpers {
+    static dumpUnionType(types) {
+        if (types.length < 2)
+            return this.dumpType(types[0]);
+        return '(' + types.map(t => this.dumpType(t)).join(' | ') + ')';
+    }
+    static dumpIntersectionType(types) {
+        if (types.length < 2)
+            return this.dumpType(types[0]);
+        return '(' + types.map(t => this.dumpType(t)).join(' | ') + ')';
+    }
     static dumpType(type, d = 0) {
         const pad0 = '    '.repeat(d);
         const pad1 = '    '.repeat(d + 1);
@@ -109,8 +119,8 @@ class DumpHelpers {
     }
     static dumpFunction(fn, padding = '') {
         // Functions should have been replaced by { __fn: ... } by the Compiler,
-        // if any is missed, this flag causes a typescript error when compiling.
-        return `/* TS BRIDGE ERROR: function not properly extracted from source. Function: ${fn.toString()} */`;
+        // if not, we try to use the JS version.
+        return `/* TS BRIDGE WARN: function not properly extracted from source. Attempting JS version (imports will not work) */ (${fn.toString()}) as any`;
     }
     static dumpValueToType(value, transform = {}, d = 2) {
         if (value === undefined) {

package/lib/compiler/stages/4_build_schemas_stage.js

@@ -17,6 +17,7 @@ class BuildSchemasStage {
         log_1.Log.info('compiler', 'stage.build_schemas', 'Building schemas...');
         const t0 = new Date().getTime();
         await this.compiler.tree.traverse('Building schemas ', async (node) => {
+            var _a;
             const module = this.compiler.modules[node.module].module;
             if (node.progressive) {
                 await module.inject({
@@ -24,6 +25,17 @@ class BuildSchemasStage {
                 });
                 return;
             }
+            // Accummulate imports from depencies
+            // (Given that dependencies are built in order)
+            node.bridge ?? (node.bridge = { imports: [] });
+            (_a = node.bridge).imports ?? (_a.imports = []);
+            for (const dep of node.dependencies) {
+                // If a dependency is inline and the node is it's root,
+                // they already share imports.
+                if (dep.node.root == node)
+                    continue;
+                node.bridge.imports.push(...(dep.node.bridge?.imports || []));
+            }
             // Inline nodes are built by their root builder
             if (node.isInline) {
                 return;

package/lib/compiler/stages/5_inject_ts_stage.js

@@ -19,7 +19,10 @@ class InjectTSStage {
         const t0 = new Date().getTime();
         const { tree } = this.compiler;
         const nodes = tree.allNodes();
-        inject_1.TSBridgeInject.inject(this.compiler, nodes);
+        tree.traverse('inject', node => {
+            inject_1.TSBridgeInject.inject(this.compiler, nodes, node);
+            return Promise.resolve();
+        });
         const t = new Date().getTime();
         log_1.Log.debug('compiler', 'stage.inject_ts', `[t: ${(t - t0) / 1000} ms]`);
         log_1.Log.trace('compiler', 'stage.inject_ts', 'Finished injecting TS code');

package/lib/compiler/stages/7_dump_stage.js

@@ -38,9 +38,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DumpStage = void 0;
 const fs = __importStar(require("fs"));
+const path_1 = __importDefault(require("path"));
 const log_1 = require("../../engine/util/log");
 const name_helpers_1 = require("../helpers/name_helpers");
-const path_1 = __importDefault(require("path"));
 const dependency_1 = require("../../engine/dependency");
 const bucket_element_1 = require("../elements/bucket.element");
 const dump_helpers_1 = require("../helpers/dump_helpers");
@@ -240,6 +240,12 @@ class DumpStage {
             Object.entries(externals.schema.buckets).forEach(([tag, ref]) => {
                 type.buckets[tag] = dependency_1.$Dependency.typeName(ref, module.lowName);
             });
+            if (!type.messages) {
+                type.messages = {};
+            }
+            Object.entries(externals.schema.messages).forEach(([tag, ref]) => {
+                type.messages[tag] = dependency_1.$Dependency.typeName(ref, module.lowName);
+            });
             if (!type.jobs) {
                 type.jobs = {};
             }

package/lib/compiler/treeshake.js

@@ -19,10 +19,12 @@ class Treeshake {
         const b = node.builder;
         const $b = b.$b;
         const buckets = b.buckets;
+        const messages = b.messages;
         const jobs = b.jobs;
         log_1.Log.trace('compiler', 'treeshake', `${'  '.repeat(depth)} └ Treeshaking node ${(0, log_1.scopeTag)($b, node.name)}`);
         node.dependencies = [
             ...Object.values(buckets),
+            ...Object.values(messages),
             ...Object.values(jobs)
         ];
         node.dependencies = this.cleanNodeDependencies(node);
@@ -141,10 +143,10 @@ class Treeshake {
                 nestedInlines.push(...deps.inlines);
             }
         }
-        // Inlines have a dependency on their parent node
+        // Inlines are a dependency of their parent node
         const inlines = [..._inlineNodes, ...nestedInlines];
         inlines.forEach(inline => {
-            inline.dependencies.push(new dependency_1.$Dependency(node.module, node.type, node.name));
+            dependencies.push(new dependency_1.$Dependency(inline.module, inline.type, inline.name));
         });
         return {
             dependencies,