nesoi 3.0.20 → 3.1.0

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) {

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

@@ -57,21 +57,25 @@ class TSBridgeOrganize {
     }
     static message(organized, tag, path, node) {
         var _a, _b;
-        const rule = path.match(/template▹0▹return▹([\w|\\.]+)▹rule▹0/);
+        const rule = path.match(/template▹0▹return▹(.+)▹rule▹0/);
         if (rule) {
             const [_, prop] = rule;
+            let path = prop.replace(/▹obj▹0▹/g, '.');
+            path = path.replace(/▹union▹/g, '.');
+            path = path.replace(/▹list▹0/g, '.#');
+            path = path.replace(/▹dict▹0/g, '.#');
             (_a = organized.messages)[tag] ?? (_a[tag] = { rules: {} });
-            (_b = organized.messages[tag].rules)[prop] ?? (_b[prop] = []);
-            organized.messages[tag].rules[prop].push(node);
+            (_b = organized.messages[tag].rules)[path] ?? (_b[path] = []);
+            organized.messages[tag].rules[path].push(node);
             return;
         }
     }
     static inlineMessage(organized, parentTag, path, node) {
-        const message = path.match(/messages▹0▹return▹([\w|\\.]*)▹(.*)/);
+        const message = path.match(/message▹(@|\w+)▹1▹return▹(.*)/);
         if (message) {
             const [_, inlineName, path] = message;
             const parent = dependency_1.$Tag.parseOrFail(parentTag);
-            const msgName = inlineName.length ? `${parent.name}.${inlineName}` : parent.name;
+            const msgName = inlineName === '@' ? parent.name : `${parent.name}.${inlineName}`;
             const msgTag = `${parent.module}::message:${msgName}`;
             const templatePath = `template▹0▹return▹${path}`;
             this.message(organized, msgTag, templatePath, node);

package/lib/compiler/typescript/typescript_compiler.d.ts

@@ -25,9 +25,7 @@ export declare class TypeScriptCompiler {
     /**
      * Extract all import nodes
      */
-    extractImports(filepath: string, $?: {
-        ignore?: string[];
-    }): string[];
+    extractImports(filepath: string): string[];
     query(filepath: string, $: {
         query: string;
         expectedKinds: ts.SyntaxKind[];
@@ -43,11 +41,11 @@ export declare class TypeScriptCompiler {
     getNesoiSymbol(name: string, path: string): ts.Symbol;
     getPropPath(node: ts.PropertyAssignment): string;
     findAllNesoiBuilders(node: ts.Node): Partial<Record<BuilderType, Record<string, ts.Node>>>;
-    findAll(node: ts.Node, predicate: (node: ts.Node) => ts.Node | undefined): ts.Node[];
+    findAll(node: ts.Node, predicate: (node: ts.Node) => ts.Node[] | undefined): ts.Node[];
     private findParent;
     private findInCallChain;
-    private findCallsUntilRoot;
-    private findCallsUntilLast;
+    private seekChainUntilLeaf;
+    private seekChainUntilRoot;
     private static logDiagnostics;
     static allFiles(dirPaths: string[]): string[];
     /**