nesoi 3.4.21 → 3.4.24

package/lib/elements/edge/controller/controller.schema.js

@@ -107,6 +107,7 @@ class $Controller {
     $t = 'controller';
     '#authn';
     '#input';
+    '#path';
     constructor(module, name, alias, auth, input, domains = {}, topics = {}) {
         this.module = module;
         this.name = name;
@@ -116,5 +117,45 @@ class $Controller {
         this.domains = domains;
         this.topics = topics;
     }
+    static endpoints(schema) {
+        const endpoints = {};
+        const _endpoint = (endpoint, path) => {
+            const path_str = this.makePath(schema, path, endpoint);
+            endpoints[path_str] = {
+                path,
+                endpoint
+            };
+        };
+        const _group = (group, path) => {
+            for (const g in group.groups) {
+                _group(group.groups[g], [...path, group]);
+            }
+            for (const e in group.endpoints) {
+                _endpoint(group.endpoints[e], [...path, group]);
+            }
+        };
+        const _domain = (domain) => {
+            for (const g in domain.groups) {
+                _group(domain.groups[g], [domain]);
+            }
+            for (const e in domain.endpoints) {
+                _endpoint(domain.endpoints[e], [domain]);
+            }
+        };
+        for (const d in schema.domains) {
+            _domain(schema.domains[d]);
+        }
+        return endpoints;
+    }
+    static makePath(schema, path, endpoint) {
+        const domain = path[0];
+        const root = `${domain.name ?? schema.name}@${domain.version}`;
+        const list = [
+            root,
+            ...path.slice(1).map(node => node.name),
+            endpoint.name
+        ];
+        return list.join('/');
+    }
 }
 exports.$Controller = $Controller;

package/lib/elements/entities/bucket/adapters/memory.bucket_adapter.js

@@ -92,13 +92,13 @@ class MemoryBucketAdapter extends bucket_adapter_1.BucketAdapter {
             throw new Error(`Object with id ${obj.id} not found for patch`);
         }
         const data = this.data[obj.id];
-        const keys = Object.entries(obj).filter(([_, val]) => val !== undefined).map(([key]) => key);
+        const keys = Object.entries(obj).filter(([_, val]) => val != null).map(([key]) => key);
         const input = this.model.copy(obj, 'save', undefined, keys);
         for (const key in input) {
             if (input[key] === null) {
                 delete data[key];
             }
-            else if (input[key] !== undefined) {
+            else if (input[key] != null) {
                 data[key] = input[key];
             }
         }

package/lib/elements/entities/bucket/adapters/memory.nql.js

@@ -5,6 +5,7 @@ const nql_engine_1 = require("../query/nql_engine");
 const tree_1 = require("../../../../engine/data/tree");
 const datetime_1 = require("../../../../engine/data/datetime");
 const bucket_model_1 = require("../model/bucket_model");
+const date_1 = require("../../../../engine/data/date");
 /**
  * @category NQL
  * */
@@ -114,7 +115,7 @@ class MemoryNQLRunner extends nql_engine_1.NQLRunner {
             if (pagination.returnTotal) {
                 totalItems = output.length;
             }
-            if (pagination.page !== undefined || pagination.perPage !== undefined) {
+            if (pagination.page != null || pagination.perPage != null) {
                 const a = ((pagination.page || 1) - 1) * (pagination.perPage ?? 10);
                 const b = a + (pagination.perPage ?? 10);
                 output = output.slice(a, b);
@@ -278,7 +279,7 @@ class MemoryNQLRunner extends nql_engine_1.NQLRunner {
                 ? tree_1.Tree.get(obj, rule.fieldpath)
                 : obj[rule.fieldpath];
             // Value is undefined, only 'present' rule applies
-            if (fieldValue === undefined) {
+            if (fieldValue == null) {
                 if (rule.op === 'present') {
                     return false;
                 }
@@ -296,12 +297,30 @@ class MemoryNQLRunner extends nql_engine_1.NQLRunner {
             // Check each operation
             // (Compatible operations and types have already been validated)
             if (rule.op === '<') {
+                if (fieldValue instanceof date_1.NesoiDate) {
+                    return fieldValue.compare(date_1.NesoiDate.from(queryValue)) < 0;
+                }
+                if (fieldValue instanceof datetime_1.NesoiDatetime) {
+                    return fieldValue.epoch < datetime_1.NesoiDatetime.parse(queryValue).epoch;
+                }
                 return fieldValue < queryValue;
             }
             if (rule.op === '<=') {
+                if (fieldValue instanceof date_1.NesoiDate) {
+                    return fieldValue.compare(date_1.NesoiDate.from(queryValue)) <= 0;
+                }
+                if (fieldValue instanceof datetime_1.NesoiDatetime) {
+                    return fieldValue.epoch <= datetime_1.NesoiDatetime.parse(queryValue).epoch;
+                }
                 return fieldValue <= queryValue;
             }
             if (rule.op === '==') {
+                if (fieldValue instanceof date_1.NesoiDate) {
+                    return fieldValue.compare(date_1.NesoiDate.from(queryValue)) == 0;
+                }
+                if (fieldValue instanceof datetime_1.NesoiDatetime) {
+                    return fieldValue.epoch == datetime_1.NesoiDatetime.parse(queryValue).epoch;
+                }
                 if (rule.case_i) {
                     return fieldValue?.toLowerCase() === queryValue?.toLowerCase();
                 }
@@ -310,9 +329,21 @@ class MemoryNQLRunner extends nql_engine_1.NQLRunner {
                 }
             }
             if (rule.op === '>') {
+                if (fieldValue instanceof date_1.NesoiDate) {
+                    return fieldValue.compare(date_1.NesoiDate.from(queryValue)) > 0;
+                }
+                if (fieldValue instanceof datetime_1.NesoiDatetime) {
+                    return fieldValue.epoch > datetime_1.NesoiDatetime.parse(queryValue).epoch;
+                }
                 return fieldValue > queryValue;
             }
             if (rule.op === '>=') {
+                if (fieldValue instanceof date_1.NesoiDate) {
+                    return fieldValue.compare(date_1.NesoiDate.from(queryValue)) >= 0;
+                }
+                if (fieldValue instanceof datetime_1.NesoiDatetime) {
+                    return fieldValue.epoch >= datetime_1.NesoiDatetime.parse(queryValue).epoch;
+                }
                 return fieldValue >= queryValue;
             }
             if (rule.op === 'in') {

package/lib/elements/entities/bucket/bucket.js

@@ -804,7 +804,7 @@ class Bucket {
             if (field.crypto) {
                 const key = trx.value(field.crypto.value.short);
                 const val = tree_1.Tree.get(obj, field.path);
-                if (val !== undefined) {
+                if (val != null) {
                     const encrypted = await crypto_1.NesoiCrypto.encrypt(val, key);
                     tree_1.Tree.set(obj, field.path, () => encrypted);
                 }
@@ -820,7 +820,7 @@ class Bucket {
             if (field.crypto) {
                 const key = trx.value(field.crypto.value.short);
                 const val = tree_1.Tree.get(obj, field.path);
-                if (val !== undefined) {
+                if (val != null) {
                     const encrypted = await crypto_1.NesoiCrypto.decrypt(val, key);
                     tree_1.Tree.set(obj, field.path, () => encrypted);
                 }

package/lib/elements/entities/bucket/model/bucket_model.js

@@ -123,7 +123,7 @@ class BucketModel {
     runCopyCmd(op, cmd, modelpath, as_json = false) {
         const next = [];
         const value = cmd.obj[cmd.key];
-        if (value === undefined || value === null) {
+        if (value == null) {
             if (cmd.field.path !== 'id' && cmd.field.required) {
                 throw error_1.NesoiError.Bucket.Model.FieldRequired({ bucket: this.alias, field: cmd.field.path, indexes: cmd.modelpath?.asterisk_values });
             }

package/lib/elements/entities/bucket/query/nql_compiler.js

@@ -5,6 +5,8 @@ const bucket_model_schema_1 = require("../model/bucket_model.schema");
 const string_1 = require("../../../../engine/util/string");
 const daemon_1 = require("../../../../engine/daemon");
 const dependency_1 = require("../../../../engine/dependency");
+const date_1 = require("../../../../engine/data/date");
+const datetime_1 = require("../../../../engine/data/datetime");
 /**
  * @category NQL
  * */
@@ -70,6 +72,8 @@ class NQL_RuleTree {
         for (const key in query) {
             const value = query[key];
             const parsedKey = await this.parseKey(meta, key);
+            if (value == null)
+                continue;
             // Fieldpath term -> Condition
             if (parsedKey.type === 'fieldpath') {
                 const parsed = await this.parseValue(value, parsedKey, meta, select);
@@ -268,6 +272,12 @@ class NQL_RuleTree {
                 }
             }
             else {
+                if (value instanceof date_1.NesoiDate) {
+                    return { static: value.toISO() };
+                }
+                if (value instanceof datetime_1.NesoiDatetime) {
+                    return { static: value.toISO() };
+                }
                 // Parameter
                 if ('.' in value) {
                     return { param: value['.'], param_is_deep: value['.'].includes('.') };

package/lib/elements/entities/constants/constants.d.ts

@@ -7,5 +7,5 @@ export declare class Enum<$ extends $ConstantEnum> {
     private schema;
     constructor(schema: $);
     keys<K extends keyof $['options']>(): K[];
-    get<K extends keyof $['options']>(key: K): $['options'][K]['value'];
+    get<K extends keyof $['options']>(key: K): $['options'][K]['value'] | undefined;
 }

package/lib/elements/entities/constants/constants.js

@@ -14,7 +14,7 @@ class Enum {
         return Object.keys(this.schema.options);
     }
     get(key) {
-        return this.schema.options[key].value;
+        return this.schema.options[key]?.value;
     }
 }
 exports.Enum = Enum;

package/lib/elements/entities/message/template/message_template_parser.js

@@ -184,7 +184,7 @@ function sanitize(field, path, value) {
  *  2: {}, [] or ''
  */
 function isEmpty(value) {
-    if (value === null || value === undefined) {
+    if (value == null) {
         return 1;
     }
     if (Array.isArray(value)) {

package/lib/engine/app/app.config.d.ts

@@ -1,4 +1,4 @@
-import type { $Space, ModuleName } from "../../schema";
+import type { $Module, $Space, ModuleName } from "../../schema";
 import type { BucketConfig } from "../../elements/entities/bucket/bucket.config";
 import type { AuthnProvider } from '../auth/authn';
 import type { ControllerConfig } from "../../elements/edge/controller/controller.config";
@@ -14,11 +14,14 @@ import type { Overlay } from '../util/type';
 import type { TrxStatus } from '../transaction/trx';
 import type { NesoiObj } from '../data/obj';
 import type { MessageTemplateDef } from "../../elements/entities/message/template/message_template.builder";
+type ModuleElementTag<M extends $Module> = `message:${keyof M['messages'] & string}` | `bucket:${keyof M['buckets'] & string}` | `job:${keyof M['jobs'] & string}` | `resource:${keyof M['resources'] & string}` | `machine:${keyof M['machines'] & string}` | `controller:${keyof M['controllers'] & string}` | `queue:${keyof M['queues'] & string}` | `topic:${keyof M['topics'] & string}`;
 export type AppModuleConfig<S extends $Space, M extends ModuleName<S>, Services extends Record<string, IService>> = {
     buckets?: AppBucketConfig<S, M, Services>;
     trash?: AppTrashConfig<Services>;
     controllers?: AppControllerConfig<S, M, Services>;
     trx?: TrxEngineConfig<S, S['modules'][M], any, Services>;
+    include?: ModuleElementTag<S['modules'][M]>[];
+    exclude?: ModuleElementTag<S['modules'][M]>[];
 };
 export type AppConfig<S extends $Space, Modules extends ModuleName<S>, Services extends Record<string, IService>> = {
     env?: $Message;
@@ -80,3 +83,4 @@ export declare class AppConfigBuilder<S extends $Space, Modules extends string =
     cli(config: CLIConfig<Services>): _App;
     compiler(config: CompilerConfig): _App;
 }
+export {};

package/lib/engine/app/app.d.ts

@@ -5,6 +5,7 @@ import type { AnyAppConfig } from './app.config';
 import type { IService } from './service';
 import { Space } from '../space';
 import { AppConfigBuilder } from './app.config';
+import { Tag } from '../dependency';
 /**
  * @category App
  */
@@ -66,5 +67,15 @@ export declare abstract class App<S extends $Space, Modules extends string = Mod
         config: AnyAppConfig;
         nesoiNpmPkg: string;
     };
+    /**
+     * Get a list of included/excluded tags per module, used by the builder
+     * to avoid including specific tags on the app.
+     */
+    static getIncludeExcludeTags(app: AnyApp): {
+        [module: string]: {
+            include?: Tag[];
+            exclude?: Tag[];
+        };
+    };
 }
 export type AnyApp = App<any, any>;

package/lib/engine/app/app.js

@@ -4,6 +4,7 @@ exports.App = void 0;
 const module_1 = require("../module");
 const space_1 = require("../space");
 const app_config_1 = require("./app.config");
+const dependency_1 = require("../dependency");
 /*
     App
 */
@@ -112,5 +113,34 @@ class App {
             nesoiNpmPkg: app._nesoiNpmPkg,
         };
     }
+    /**
+     * Get a list of included/excluded tags per module, used by the builder
+     * to avoid including specific tags on the app.
+     */
+    static getIncludeExcludeTags(app) {
+        if (!app._config.modules)
+            return {};
+        const tags = {};
+        for (const m in app._config.modules) {
+            const module = app._config.modules[m];
+            if (module.include) {
+                tags[m] ??= {};
+                tags[m].include ??= [];
+                for (const ref of module.include) {
+                    const [type, name] = ref.split(':');
+                    tags[m].include.push(new dependency_1.Tag(m, type, name));
+                }
+            }
+            if (module.exclude) {
+                tags[m] ??= {};
+                tags[m].exclude ??= [];
+                for (const ref of module.exclude) {
+                    const [type, name] = ref.split(':');
+                    tags[m].exclude.push(new dependency_1.Tag(m, type, name));
+                }
+            }
+        }
+        return tags;
+    }
 }
 exports.App = App;

package/lib/engine/app/inline.app.js

@@ -45,6 +45,7 @@ class InlineApp extends app_1.App {
         const tree = new tree_1.ModuleTree(this._modules, {
             exclude: ['*.test.ts']
         });
+        const tags = app_1.App.getIncludeExcludeTags(this);
         await tree.resolve();
         await tree.traverse('Building', async (node) => {
             // Inline nodes are built by their root builder
@@ -52,7 +53,7 @@ class InlineApp extends app_1.App {
                 return;
             }
             const module = this._modules[node.tag.module];
-            await builder_1.Builder.buildNode(module, node, tree);
+            await builder_1.Builder.buildNode(module, node, tree, tags);
         });
     }
     /**

package/lib/engine/builder.d.ts

@@ -1,6 +1,7 @@
-import type { ResolvedBuilderNode } from './dependency';
+import { type ResolvedBuilderNode } from './dependency';
 import type { ModuleTree } from './tree';
 import type { AnyModule } from './module';
+import type { Compiler } from "../compiler";
 export declare class Builder {
     /**
      * Build a resolved builder node, then merge the
@@ -10,7 +11,8 @@ export declare class Builder {
      * @param node A resolved builder node
      * @param tree A module tree
      */
-    static buildNode(module: AnyModule, node: ResolvedBuilderNode, tree: ModuleTree): void;
+    static buildNode(module: AnyModule, node: ResolvedBuilderNode, tree: ModuleTree, tags?: Compiler['tags']): void;
+    static filterNode(module: string, node: ResolvedBuilderNode, tags?: Compiler['tags']): boolean;
     /**
      * Merge inline message schemas into the module.
      *

package/lib/engine/builder.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Builder = void 0;
+const dependency_1 = require("./dependency");
 const log_1 = require("./util/log");
 const error_1 = require("./data/error");
 const message_builder_1 = require("../elements/entities/message/message.builder");
@@ -23,8 +24,9 @@ class Builder {
      * @param node A resolved builder node
      * @param tree A module tree
      */
-    static buildNode(module, node, tree) {
+    static buildNode(module, node, tree, tags) {
         log_1.Log.trace('builder', 'module', `Building ${module.name}::${(0, log_1.scopeTag)(node.builder.$b, node.builder.name)}`);
+        const add_root = this.filterNode(module.name, node, tags);
         if (node.builder.$b === 'constants') {
             module.schema.constants = constants_builder_1.ConstantsBuilder.build(node);
         }
@@ -32,45 +34,99 @@ class Builder {
             module.schema.externals = externals_builder_1.ExternalsBuilder.build(node, tree);
         }
         else if (node.builder.$b === 'bucket') {
-            module.schema.buckets[node.tag.name] = bucket_builder_1.BucketBuilder.build(node, tree);
+            if (add_root) {
+                module.schema.buckets[node.tag.name] = bucket_builder_1.BucketBuilder.build(node, tree);
+            }
         }
         else if (node.builder.$b === 'message') {
-            module.schema.messages[node.tag.name] = message_builder_1.MessageBuilder.build(node, tree, module.schema);
+            if (add_root) {
+                module.schema.messages[node.tag.name] = message_builder_1.MessageBuilder.build(node, tree, module.schema);
+            }
         }
         else if (node.builder.$b === 'job') {
             const { schema, inlineMessages } = job_builder_1.JobBuilder.build(node, tree, module.schema);
-            module.schema.jobs[node.tag.name] = schema;
+            if (add_root) {
+                module.schema.jobs[node.tag.name] = schema;
+            }
             this.mergeInlineMessages(module, inlineMessages);
         }
         else if (node.builder.$b === 'resource') {
             const { schema, inlineMessages, inlineJobs } = resource_builder_1.ResourceBuilder.build(node, tree, module.schema);
-            module.schema.resources[schema.name] = schema;
+            if (add_root) {
+                module.schema.resources[schema.name] = schema;
+            }
             this.mergeInlineMessages(module, inlineMessages);
             this.mergeInlineJobs(module, inlineJobs);
         }
         else if (node.builder.$b === 'machine') {
             const { schema, inlineMessages, inlineJobs } = machine_builder_1.MachineBuilder.build(node, tree, module.schema);
-            module.schema.machines[schema.name] = schema;
+            if (add_root) {
+                module.schema.machines[schema.name] = schema;
+            }
             this.mergeInlineMessages(module, inlineMessages);
             this.mergeInlineJobs(module, inlineJobs);
         }
         else if (node.builder.$b === 'controller') {
-            module.schema.controllers[node.tag.name] = controller_builder_1.ControllerBuilder.build(node);
+            if (add_root) {
+                module.schema.controllers[node.tag.name] = controller_builder_1.ControllerBuilder.build(node);
+            }
         }
         else if (node.builder.$b === 'queue') {
             const { schema, inlineMessages } = queue_builder_1.QueueBuilder.build(node, tree, module.schema);
-            module.schema.queues[node.tag.name] = schema;
+            if (add_root) {
+                module.schema.queues[node.tag.name] = schema;
+            }
             this.mergeInlineMessages(module, inlineMessages);
         }
         else if (node.builder.$b === 'topic') {
             const { schema, inlineMessages } = topic_builder_1.TopicBuilder.build(node, tree, module.schema);
-            module.schema.topics[node.tag.name] = schema;
+            if (add_root) {
+                module.schema.topics[node.tag.name] = schema;
+            }
             this.mergeInlineMessages(module, inlineMessages);
         }
         else {
             throw error_1.NesoiError.Module.UnknownBuilderType(module, node.filepath.toString(), node.tag.name, node.builder.$b);
         }
     }
+    static filterNode(module, node, tags) {
+        let add_root = true;
+        // Filter elements with include/exclude
+        const module_tags = tags?.[module];
+        if (module_tags?.include) {
+            if (!module_tags.include.some(t => dependency_1.Tag.matches(t, node.tag))) {
+                node.filtered = true;
+                add_root = false;
+            }
+            for (const type of ['message', 'job']) {
+                if (node.inlines[type]) {
+                    for (const name in node.inlines[type]) {
+                        if (!module_tags.include.some(t => dependency_1.Tag.matches(t, node.inlines[type][name].tag))) {
+                            node.inlines[type][name].filtered = true;
+                            delete node.inlines[type][name];
+                        }
+                    }
+                }
+            }
+        }
+        if (module_tags?.exclude) {
+            if (module_tags.exclude.some(t => dependency_1.Tag.matches(t, node.tag))) {
+                node.filtered = true;
+                add_root = false;
+            }
+            for (const type of ['message', 'job']) {
+                if (node.inlines[type]) {
+                    for (const name in node.inlines[type]) {
+                        if (module_tags.exclude.some(t => dependency_1.Tag.matches(t, node.inlines[type][name].tag))) {
+                            node.inlines[type][name].filtered = true;
+                            delete node.inlines[type][name];
+                        }
+                    }
+                }
+            }
+        }
+        return add_root;
+    }
     /**
      * Merge inline message schemas into the module.
      *

package/lib/engine/data/error.d.ts

@@ -337,6 +337,14 @@ export declare namespace NesoiError {
         function UnmetCondition(alias: string, msg: string): BaseError;
     }
     namespace Controller {
+        function DomainNotFound($: {
+            domain: string;
+            controller: string;
+        }): BaseError;
+        function EndpointNotFound($: {
+            endpoint: string;
+            controller: string;
+        }): BaseError;
         function SubscribeFailed($: {
             topic: string;
         }): BaseError;

package/lib/engine/data/error.js

@@ -507,6 +507,14 @@ var NesoiError;
     */
     let Controller;
     (function (Controller) {
+        function DomainNotFound($) {
+            return new BaseError('Controller.DomainNotFound', `Domain '${$.domain}' not found on controller '${$.controller}'`, Status.BAD_REQUEST, $);
+        }
+        Controller.DomainNotFound = DomainNotFound;
+        function EndpointNotFound($) {
+            return new BaseError('Controller.DomainNotFound', `Endpoint '${$.endpoint}' not found on controller '${$.controller}'`, Status.BAD_REQUEST, $);
+        }
+        Controller.EndpointNotFound = EndpointNotFound;
         function SubscribeFailed($) {
             return new BaseError('Controller.SubscribeFailed', `Failed to subscribe to topic '${$.topic}'`, Status.BAD_REQUEST, $);
         }

package/lib/engine/data/tree.js

@@ -30,6 +30,9 @@ class Tree {
             if (ref === undefined) {
                 return undefined;
             }
+            if (ref === null) {
+                return null;
+            }
         }
         // When reading from a TypeAsObj,
         // advance on unions
@@ -103,7 +106,7 @@ class Tree {
             else {
                 ref.walk(path);
             }
-            if (ref.get() === undefined) {
+            if (ref.get() == null) {
                 ref.replace(replacer, __index);
                 return;
             }

package/lib/engine/dependency.d.ts

@@ -102,6 +102,7 @@ export type ResolvedBuilderNode = Overlay<BuilderNode, {
     };
     root?: ResolvedBuilderNode;
     layered?: boolean;
+    filtered?: boolean;
     schema?: AnyElementSchema;
     bridge?: {
         imports?: string[];

package/lib/engine/transaction/nodes/controller.trx_node.d.ts

@@ -0,0 +1,17 @@
+import type { $Module, $Space } from "../../../schema";
+import type { $Controller } from "../../../elements/edge/controller/controller.schema";
+import { TrxNode } from '../trx_node';
+import { Tag } from "../../dependency";
+/**
+ * @category Engine
+ * @subcategory Transaction
+ */
+export declare class ControllerTrxNode<S extends $Space, M extends $Module, $ extends $Controller> {
+    private trx;
+    private tag;
+    private external;
+    private controller?;
+    constructor(trx: TrxNode<any, M, any>, tag: Tag);
+    private wrap;
+    invoke<Path extends keyof $['#path']>(path: Path, raw: $['#path'][Path]['#raw']): Promise<void>;
+}

package/lib/engine/transaction/nodes/controller.trx_node.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ControllerTrxNode = void 0;
+const trx_node_1 = require("../trx_node");
+const external_trx_node_1 = require("./external.trx_node");
+const dependency_1 = require("../../dependency");
+const error_1 = require("../../data/error");
+/**
+ * @category Engine
+ * @subcategory Transaction
+ */
+class ControllerTrxNode {
+    trx;
+    tag;
+    external;
+    controller;
+    constructor(trx, tag) {
+        this.trx = trx;
+        this.tag = tag;
+        const module = trx_node_1.TrxNode.getModule(trx);
+        this.external = tag.module !== module.name;
+        if (!this.external) {
+            this.controller = dependency_1.Tag.element(tag, trx);
+            if (!this.controller) {
+                throw error_1.NesoiError.Trx.NodeNotFound(this.tag.full, trx.globalId);
+            }
+        }
+    }
+    /*
+        Wrap
+    */
+    async wrap(action, input, fn, fmtTrxOut) {
+        const wrapped = async (parentTrx, controller) => {
+            const trx = trx_node_1.TrxNode.makeChildNode(parentTrx, controller.schema.module, 'controller', controller.schema.name);
+            trx_node_1.TrxNode.open(trx, action, input);
+            let out;
+            try {
+                out = await fn(trx, controller);
+            }
+            catch (e) {
+                throw trx_node_1.TrxNode.error(trx, e);
+            }
+            trx_node_1.TrxNode.ok(trx, fmtTrxOut ? fmtTrxOut(out) : out);
+            return out;
+        };
+        if (this.external) {
+            const ext = new external_trx_node_1.ExternalTrxNode(this.trx, this.tag);
+            return ext.run_and_hold(trx => dependency_1.Tag.element(this.tag, trx), wrapped);
+        }
+        else {
+            return wrapped(this.trx, this.controller);
+        }
+    }
+    async invoke(path, raw) {
+        return this.wrap('invoke', raw, (_, controller) => {
+            return controller.adapter.invoke(path, raw);
+        });
+    }
+}
+exports.ControllerTrxNode = ControllerTrxNode;

package/lib/engine/transaction/trx_node.d.ts

@@ -14,6 +14,7 @@ import { ResourceTrxNode } from './nodes/resource.trx_node';
 import { MachineTrxNode } from './nodes/machine.trx_node';
 import { Enum } from "../../elements/entities/constants/constants";
 import { TopicTrxNode } from './nodes/topic.trx_node';
+import { ControllerTrxNode } from './nodes/controller.trx_node';
 export type TrxNodeBlock = 'bucket' | 'message' | 'job' | 'resource' | 'machine' | 'queue' | 'topic' | 'controller' | 'externals';
 export type TrxNodeState = 'open' | 'hold' | 'ok' | 'error';
 export type TrxNodeStatus = {
@@ -70,6 +71,7 @@ export declare class TrxNode<Space extends $Space, M extends $Module, AuthUsers
     static jobWithCustomCtx<M extends $Module, JobName extends keyof M['jobs'], Job extends M['jobs'][JobName]>(node: AnyTrxNode, name: string, ctx?: Record<string, any>): JobTrxNode<M, Job>;
     resource<Name extends keyof M['resources'], Resource extends M['resources'][Name]>(name: Name): ResourceTrxNode<M, Resource>;
     machine<Name extends keyof M['machines'], Machine extends M['machines'][Name]>(name: Name): MachineTrxNode<M, Machine>;
+    controller<Name extends keyof M['controllers'], Controller extends M['controllers'][Name]>(name: Name): ControllerTrxNode<Space, M, Controller>;
     queue<Name extends keyof M['queues'], Queue extends M['queues'][Name]>(name: Name): QueueTrxNode<M, Queue>;
     topic<Name extends keyof M['topics'], topic extends M['topics'][Name]>(name: Name): TopicTrxNode<Space, M, topic>;
     authenticate(tokens: AuthRequest<keyof AuthUsers>): Promise<TrxNode<$Space, $Module, AuthUsers>>;