nesoi 3.0.21 → 3.1.1

package/lib/compiler/helpers/dump_helpers.js

@@ -2,9 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DumpHelpers = void 0;
 class DumpHelpers {
-    static dumpType(type, d = 0) {
-        const pad0 = '    '.repeat(d);
-        const pad1 = '    '.repeat(d + 1);
+    static dumpUnionType(types, singleLine = false) {
+        if (types.length < 2)
+            return this.dumpType(types[0], singleLine);
+        return '(' + types.map(t => this.dumpType(t, singleLine)).join(' | ') + ')';
+    }
+    static dumpIntersectionType(types, singleLine = false) {
+        if (types.length < 2)
+            return this.dumpType(types[0], singleLine);
+        return '(' + types.map(t => this.dumpType(t, singleLine)).join(' | ') + ')';
+    }
+    static dumpType(type, singleLine = false, d = 0) {
+        const pad0 = singleLine ? ' ' : '    '.repeat(d);
+        const pad1 = singleLine ? ' ' : '    '.repeat(d + 1);
+        const lb = singleLine ? '' : '\n';
         let str = '';
         if (typeof type === 'undefined') {
             str = 'never';
@@ -17,20 +28,25 @@ class DumpHelpers {
         }
         else if (Array.isArray(type)) {
             if (type.length) {
-                str = '(' + type.map(t => this.dumpType(t)).join(' | ') + ')';
+                str = '(' + type.map(t => this.dumpType(t, singleLine)).join(' | ') + ')';
             }
             else {
                 str = 'never';
             }
         }
         else {
-            str = '{\n' +
+            str = '{' + lb +
                 Object.entries(type)
                     .filter(([key]) => !['__array', '__optional', '__or'].includes(key))
                     .map(([key, value]) => {
                     let k = key;
+                    // If key contains ${, it's a template string
+                    if (k.includes('${')) {
+                        // Put single quotes around non-alphanumeric keys
+                        k = '[_: `' + key + '`]';
+                    }
                     // If key is not a special [],
-                    if (!(k.startsWith('[') && k.endsWith(']'))
+                    else if (!(k.startsWith('[') && k.endsWith(']'))
                         && !(k.startsWith('`') && k.endsWith('`'))) {
                         // Put single quotes around non-alphanumeric keys
                         k = /[^\w]/.exec(key) ? `'${key}'` : key;
@@ -48,14 +64,14 @@ class DumpHelpers {
                         k += '?';
                     }
                     // Dump element type
-                    const t = this.dumpType(value, d + 1);
+                    const t = this.dumpType(value, singleLine, d + 1);
                     return `${pad1}${k}: ${t}`;
-                }).join(',\n')
-                + `\n${pad0}}`;
+                }).join(',' + lb)
+                + `${lb}${pad0}}`;
         }
         if (typeof type === 'object') {
             if (type.__or) {
-                str += ' | ' + this.dumpType(type.__or, d);
+                str += ' | ' + this.dumpType(type.__or, singleLine, d);
             }
             if (type.__array) {
                 str = `(${str})[]`;
@@ -66,9 +82,10 @@ class DumpHelpers {
         }
         return str;
     }
-    static dumpSchema(val, d = 0) {
-        const pad0 = '    '.repeat(d);
-        const pad1 = '    '.repeat(d + 1);
+    static dumpSchema(val, singleLine = false, d = 0) {
+        const pad0 = singleLine ? ' ' : '    '.repeat(d);
+        const pad1 = singleLine ? ' ' : '    '.repeat(d + 1);
+        const lb = singleLine ? '' : '\n';
         if (typeof val === 'undefined') {
             return 'undefined';
         }
@@ -85,22 +102,22 @@ class DumpHelpers {
             return val.description || 'undefined';
         }
         else if (Array.isArray(val)) {
-            return '[\n' +
+            return '[' + lb +
                 val.map(child => {
-                    return `${pad1}${this.dumpSchema(child, d + 1)}`;
-                }).join(',\n')
-                + `\n${pad0}]`;
+                    return `${pad1}${this.dumpSchema(child, singleLine, d + 1)}`;
+                }).join(',' + lb)
+                + `${lb}${pad0}]`;
         }
         else if (typeof val === 'object') {
             if ('__fn' in val) {
                 return val.__fn;
             }
-            return '{\n' +
+            return '{' + lb +
                 Object.entries(val).map(([key, child]) => {
                     const _key = key.match(/\W/) ? `'${key}'` : key;
-                    return `${pad1}${_key}: ${this.dumpSchema(child, d + 1)}`;
-                }).join(',\n')
-                + `\n${pad0}}`;
+                    return `${pad1}${_key}: ${this.dumpSchema(child, singleLine, d + 1)}`;
+                }).join(',' + lb)
+                + `${lb}${pad0}}`;
         }
         else if (typeof val === 'function') {
             return this.dumpFunction(val, pad0);
@@ -109,10 +126,10 @@ 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) {
+    static dumpValueToType(value, transform = {}, singleLine = false, d = 2) {
         if (value === undefined) {
             return 'undefined';
         }
@@ -133,7 +150,7 @@ class DumpHelpers {
                 if (value.length === 0) {
                     return 'never[]';
                 }
-                return '[' + value.map((v) => DumpHelpers.dumpType(this.dumpValueToType(v, transform, d + 1), d)).join(', ') + ']';
+                return '[' + value.map((v) => DumpHelpers.dumpType(this.dumpValueToType(v, transform, singleLine, d + 1), singleLine, d)).join(', ') + ']';
             }
             else {
                 const obj = {};
@@ -148,7 +165,7 @@ class DumpHelpers {
                         obj[key] = transform[key](value);
                     }
                     else {
-                        obj[key] = this.dumpValueToType(value, transform[key], d + 1);
+                        obj[key] = this.dumpValueToType(value, transform[key], singleLine, d + 1);
                     }
                 });
                 return obj;

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,

package/lib/compiler/typescript/bridge/extract.js

@@ -45,9 +45,7 @@ class TSBridgeExtract {
             }
             return;
         }
-        const imports = tsCompiler.extractImports(node.filepath, {
-            ignore: [] // TODO: ignore space file
-        });
+        const imports = tsCompiler.extractImports(node.filepath);
         if (imports.length) {
             log_1.Log.debug('compiler', 'bridge.extract', `Extracted TS imports from ${node.filepath}`, imports);
         }
@@ -103,141 +101,89 @@ class TSBridgeExtract {
         }
         if (node.builder.$b === 'message') {
             functions.push(...tsCompiler.query(node.filepath, {
-                query: 'message.*.template.0.return.**.rule.0',
-                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+                query: 'message.*.template.0.return.*.rule.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression, ts.SyntaxKind.PropertyAccessExpression]
             }));
-        }
-        if (node.builder.$b === 'job') {
             functions.push(...tsCompiler.query(node.filepath, {
-                query: 'job.*.messages.0.return.*.**.rule.0',
-                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+                query: 'message.*.template.0.return.*.{~.#.*?}.rule.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression, ts.SyntaxKind.PropertyAccessExpression]
             }));
+        }
+        if (node.builder.$b === 'job') {
             functions.push(...tsCompiler.query(node.filepath, {
-                query: 'job.*.extra.0',
-                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+                query: 'job.*.message.1.return.*.rule.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression, ts.SyntaxKind.PropertyAccessExpression]
             }));
             functions.push(...tsCompiler.query(node.filepath, {
-                query: 'job.*.assert.0',
-                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+                query: 'job.*.message.1.return.*.{~.#.*?}.rule.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression, ts.SyntaxKind.PropertyAccessExpression]
             }));
             functions.push(...tsCompiler.query(node.filepath, {
-                query: 'job.*.method.0',
+                query: 'job.*.extra|assert|method.0',
                 expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
             }));
         }
         if (node.builder.$b === 'resource') {
             functions.push(...tsCompiler.query(node.filepath, {
-                query: 'resource.*.create.0.return.input.0.return.**.rule.0',
-                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
-            }));
-            functions.push(...tsCompiler.query(node.filepath, {
-                query: 'resource.*.create.0.return.extra.0',
-                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
-            }));
-            functions.push(...tsCompiler.query(node.filepath, {
-                query: 'resource.*.create.0.return.assert.0',
-                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
-            }));
-            functions.push(...tsCompiler.query(node.filepath, {
-                query: 'resource.*.create.0.return.prepare.0',
-                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+                query: 'resource.*.create.0.return.input.0.return.*.rule.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression, ts.SyntaxKind.PropertyAccessExpression]
             }));
             functions.push(...tsCompiler.query(node.filepath, {
-                query: 'resource.*.create.0.return.after.0',
-                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+                query: 'resource.*.create.0.return.input.0.return.*.{~.#.*?}.rule.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression, ts.SyntaxKind.PropertyAccessExpression]
             }));
             functions.push(...tsCompiler.query(node.filepath, {
-                query: 'resource.*.update.0.return.input.0.return.**.rule.0',
+                query: 'resource.*.create.0.return.extra|assert|prepare|after.0',
                 expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
             }));
             functions.push(...tsCompiler.query(node.filepath, {
-                query: 'resource.*.update.0.return.extra.0',
-                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+                query: 'resource.*.update.0.return.input.0.return.*.rule.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression, ts.SyntaxKind.PropertyAccessExpression]
             }));
             functions.push(...tsCompiler.query(node.filepath, {
-                query: 'resource.*.update.0.return.assert.0',
-                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+                query: 'resource.*.update.0.return.input.0.return.*.{~.#.*?}.rule.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression, ts.SyntaxKind.PropertyAccessExpression]
             }));
             functions.push(...tsCompiler.query(node.filepath, {
-                query: 'resource.*.update.0.return.prepare.0',
+                query: 'resource.*.update.0.return.extra|assert|prepare|after.0',
                 expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
             }));
             functions.push(...tsCompiler.query(node.filepath, {
-                query: 'resource.*.update.0.return.after.0',
-                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+                query: 'resource.*.delete.0.return.input.0.return.*.rule.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression, ts.SyntaxKind.PropertyAccessExpression]
             }));
             functions.push(...tsCompiler.query(node.filepath, {
-                query: 'resource.*.delete.0.return.input.0.return.**.rule.0',
-                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
-            }));
-            functions.push(...tsCompiler.query(node.filepath, {
-                query: 'resource.*.delete.0.return.extra.0',
-                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+                query: 'resource.*.delete.0.return.input.0.return.*.{~.#.*?}.rule.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression, ts.SyntaxKind.PropertyAccessExpression]
             }));
             functions.push(...tsCompiler.query(node.filepath, {
-                query: 'resource.*.delete.0.return.assert.0',
-                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
-            }));
-            functions.push(...tsCompiler.query(node.filepath, {
-                query: 'resource.*.delete.0.return.prepare.0',
-                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
-            }));
-            functions.push(...tsCompiler.query(node.filepath, {
-                query: 'resource.*.delete.0.return.after.0',
+                query: 'resource.*.delete.0.return.extra|assert|prepare|after.0',
                 expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
             }));
         }
         if (node.builder.$b === 'machine') {
             functions.push(...tsCompiler.query(node.filepath, {
-                query: 'machine.*.messages.0.return.*.**.rule.0',
-                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+                query: 'machine.*.message.1.return.**.rule.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression, ts.SyntaxKind.PropertyAccessExpression]
             }));
             functions.push(...tsCompiler.query(node.filepath, {
-                query: 'machine.*.{state.1.return}.beforeEnter.0.return.extra.0',
-                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+                query: 'machine.*.message.1.return.{**.obj.0}.**.rule.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression, ts.SyntaxKind.PropertyAccessExpression]
             }));
             functions.push(...tsCompiler.query(node.filepath, {
-                query: 'machine.*.{state.1.return}.beforeEnter.0.return.assert.0',
+                query: 'machine.*.{state.1.return}.beforeEnter.0.return.extra|assert|method.0',
                 expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
             }));
             functions.push(...tsCompiler.query(node.filepath, {
-                query: 'machine.*.{state.1.return}.beforeEnter.0.return.method.0',
+                query: 'machine.*.{state.1.return}.afterEnter.0.return.extra|assert|method.0',
                 expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
             }));
             functions.push(...tsCompiler.query(node.filepath, {
-                query: 'machine.*.{state.1.return}.afterEnter.0.return.extra.0',
+                query: 'machine.*.{state.1.return}.beforeLeave.0.return.extra|assert|method.0',
                 expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
             }));
             functions.push(...tsCompiler.query(node.filepath, {
-                query: 'machine.*.{state.1.return}.afterEnter.0.return.assert.0',
-                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
-            }));
-            functions.push(...tsCompiler.query(node.filepath, {
-                query: 'machine.*.{state.1.return}.afterEnter.0.return.method.0',
-                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
-            }));
-            functions.push(...tsCompiler.query(node.filepath, {
-                query: 'machine.*.{state.1.return}.beforeLeave.0.return.extra.0',
-                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
-            }));
-            functions.push(...tsCompiler.query(node.filepath, {
-                query: 'machine.*.{state.1.return}.beforeLeave.0.return.assert.0',
-                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
-            }));
-            functions.push(...tsCompiler.query(node.filepath, {
-                query: 'machine.*.{state.1.return}.beforeLeave.0.return.method.0',
-                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
-            }));
-            functions.push(...tsCompiler.query(node.filepath, {
-                query: 'machine.*.{state.1.return}.afterLeave.0.return.extra.0',
-                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
-            }));
-            functions.push(...tsCompiler.query(node.filepath, {
-                query: 'machine.*.{state.1.return}.afterLeave.0.return.assert.0',
-                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
-            }));
-            functions.push(...tsCompiler.query(node.filepath, {
-                query: 'machine.*.{state.1.return}.afterLeave.0.return.method.0',
+                query: 'machine.*.{state.1.return}.afterLeave.0.return.extra|assert|method.0',
                 expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
             }));
             functions.push(...tsCompiler.query(node.filepath, {
@@ -249,27 +195,11 @@ class TSBridgeExtract {
                 expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
             }));
             functions.push(...tsCompiler.query(node.filepath, {
-                query: 'machine.*.{state.1.return}.transition.1.return.runJob.0.return.extra.0',
-                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
-            }));
-            functions.push(...tsCompiler.query(node.filepath, {
-                query: 'machine.*.{state.1.return}.transition.1.return.{else.0.return}.runJob.0.return.extra.0',
-                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
-            }));
-            functions.push(...tsCompiler.query(node.filepath, {
-                query: 'machine.*.{state.1.return}.transition.1.return.runJob.0.return.assert.0',
-                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
-            }));
-            functions.push(...tsCompiler.query(node.filepath, {
-                query: 'machine.*.{state.1.return}.transition.1.return.{else.0.return}.runJob.0.return.assert.0',
-                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
-            }));
-            functions.push(...tsCompiler.query(node.filepath, {
-                query: 'machine.*.{state.1.return}.transition.1.return.runJob.0.return.method.0',
+                query: 'machine.*.{state.1.return}.transition.1.return.runJob.0.return.extra|assert|method.0',
                 expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
             }));
             functions.push(...tsCompiler.query(node.filepath, {
-                query: 'machine.*.{state.1.return}.transition.1.return.{else.0.return}.runJob.0.return.method.0',
+                query: 'machine.*.{state.1.return}.transition.1.return.{else.0.return}.runJob.0.return.extra|assert|method.0',
                 expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
             }));
         }

package/lib/compiler/typescript/bridge/inject.d.ts

@@ -1,7 +1,7 @@
 import { ResolvedBuilderNode } from "../../../engine/dependency";
 import { Compiler } from "../../compiler";
 export declare class TSBridgeInject {
-    static inject(compiler: Compiler, nodes: ResolvedBuilderNode[]): void;
+    static inject(compiler: Compiler, nodes: ResolvedBuilderNode[], node: ResolvedBuilderNode): void;
     private static bucket;
     private static message;
     private static job;

package/lib/compiler/typescript/bridge/inject.js

@@ -2,40 +2,37 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TSBridgeInject = void 0;
 const log_1 = require("../../../engine/util/log");
+const message_template_schema_1 = require("../../../elements/entities/message/template/message_template.schema");
 const name_helpers_1 = require("../../helpers/name_helpers");
 class TSBridgeInject {
-    static inject(compiler, nodes) {
+    static inject(compiler, nodes, node) {
         const { tsCompiler } = compiler;
-        nodes.forEach(node => {
-            if (node.progressive)
+        if (node.progressive)
+            return;
+        log_1.Log.debug('compiler', 'bridge.inject', `Injecting TS code on ${node.tag}`);
+        const schema = node.schema;
+        if (schema.$t === 'bucket') {
+            const extract = node.bridge?.extract;
+            if (!extract)
                 return;
-            log_1.Log.debug('compiler', 'bridge.inject', `Injecting TS code on ${node.tag}`);
-            const schema = node.schema;
-            if (schema.$t === 'bucket') {
-                const extract = node.bridge?.extract;
-                if (!extract)
-                    return;
-                this.bucket(compiler, extract, node);
-            }
-            if (schema.$t === 'message') {
-                const extract = node.bridge?.extract;
-                if (!extract)
-                    return;
-                this.message(compiler, extract, node);
-            }
-            if (schema.$t === 'job') {
-                const extract = node.bridge?.extract;
-                if (!extract)
-                    return;
-                this.job(compiler, extract, node);
-            }
-            if (schema.$t === 'machine') {
-                const extract = node.bridge?.extract;
-                if (!extract)
-                    return;
-                this.machine(compiler, extract, node);
-            }
-        });
+            this.bucket(compiler, extract, node);
+        }
+        if (schema.$t === 'message') {
+            const extract = node.bridge?.extract;
+            this.message(compiler, extract, nodes, node);
+        }
+        if (schema.$t === 'job') {
+            const extract = node.bridge?.extract;
+            if (!extract)
+                return;
+            this.job(compiler, extract, node);
+        }
+        if (schema.$t === 'machine') {
+            const extract = node.bridge?.extract;
+            if (!extract)
+                return;
+            this.machine(compiler, extract, node);
+        }
     }
     static bucket(compiler, extract, node) {
         const { tsCompiler } = compiler;
@@ -47,7 +44,7 @@ class TSBridgeInject {
                 prop.split('.').forEach(p => {
                     f = f.children[p];
                 });
-                f.value.computed = { fn: {
+                f.meta.computed = { fn: {
                         __fn: tsCompiler.getFnText(node),
                         __fn_type: '(...args: any[]) => any', // TODO: evaluate
                     } };
@@ -55,22 +52,53 @@ class TSBridgeInject {
             });
         });
     }
-    static message(compiler, extract, node) {
+    static message(compiler, extract, nodes, node) {
         const { tsCompiler } = compiler;
         const schema = node.schema;
-        const typeName = name_helpers_1.NameHelpers.names(schema).type;
-        Object.entries(extract.rules).forEach(([prop, node]) => {
-            let f = { children: schema.template.fields };
-            let addr = '';
-            prop.split('.').forEach(p => {
-                f = f.children[p];
-                addr += `['${p}${f.type === 'id' ? '_id' : ''}']`;
-            });
-            const type = `$MessageTemplateRule<${typeName}['#raw']${addr}, ${typeName}['#raw']>`;
-            f.rules = node.map(fn => ({
-                __fn: tsCompiler.getFnText(fn),
-                __fn_type: '(...args: any[]) => any', // TODO: evaluate
-            }));
+        const _extract = extract ? { rules: { ...extract.rules } } : { rules: {} };
+        // Step 1: Go through all .msg() fields of the message,
+        // and join the referenced extract into this.
+        message_template_schema_1.$MessageTemplate.forEachField(schema.template, (field, path) => {
+            if (!field.meta.msg)
+                return;
+            const ref = nodes.find(node => node.tag === field.meta.msg.tag);
+            if (!ref) {
+                throw new Error(`Unable to inject code from .msg() field, ${field.meta.msg.tag} not found`);
+            }
+            const refExtract = ref.bridge?.extract;
+            if (!refExtract)
+                return;
+            for (const key in refExtract.rules) {
+                const _path = path + '.' + key;
+                _extract.rules[_path] = refExtract.rules[key];
+            }
+        });
+        const getFields = (root, prop) => {
+            const path = prop.split('.');
+            let poll = [root];
+            for (const p of path) {
+                if (poll.length === 0)
+                    break;
+                // Walk to next layer of fields by path
+                const next = [];
+                for (const n of poll) {
+                    const child = n.children?.[p];
+                    if (child) {
+                        next.push(child);
+                    }
+                }
+                poll = next;
+            }
+            return poll;
+        };
+        Object.entries(_extract?.rules || {}).forEach(([path, rules]) => {
+            const fields = getFields({ children: schema.template.fields }, path);
+            for (const field of fields) {
+                field.rules = rules.map(fn => ({
+                    __fn: tsCompiler.getFnText(fn),
+                    __fn_type: '(...args: any[]) => any',
+                }));
+            }
         });
     }
     static job(compiler, extract, node) {