nesoi 3.1.6 → 3.1.7

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

@@ -161,6 +161,14 @@ class DumpModulesStage {
             });
             str += '    ],';
         }
+        const topics = Object.values(module.module.schema.topics || {});
+        if (topics.length) {
+            str += '\n    topics: [\n';
+            topics.forEach(topic => {
+                str += `      require('./${module.lowName}/topic__${topic.name}').default,\n`;
+            });
+            str += '    ],';
+        }
         str += '})';
         const moduleFilename = `${module.lowName}.js`;
         const modulePath = path.resolve(dir, moduleFilename);

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

@@ -6,6 +6,7 @@ import { $Queue } from "../../elements/blocks/queue/queue.schema";
 import { Compiler } from '../compiler';
 import { $Block } from "../../elements/blocks/block.schema";
 import { ProgressiveBuildCache } from '../progressive';
+import { $Topic } from "../../elements";
 export type TypeAsObj = string | ({
     [x: string]: TypeAsObj;
 } & {
@@ -45,7 +46,7 @@ export declare abstract class Element<T extends AnyElementSchema> {
         __optional?: boolean;
         __or?: TypeAsObj;
     } & Record<string, any>) | "{}";
-    static makeIOType(compiler: Compiler, schema: $Job | $Machine | $MachineState | $MachineTransition | $Queue): {
+    static makeIOType(compiler: Compiler, schema: $Job | $Machine | $MachineState | $MachineTransition | $Queue | $Topic): {
         input: string;
         output: {};
     };

package/lib/compiler/elements/element.js

@@ -58,6 +58,7 @@ class Element {
             'machine': '$Machine',
             'controller': '$Controller',
             'queue': '$Queue',
+            'topic': '$Topic',
         }[this.$t];
         return `export interface ${this.typeName} extends ${typeschema} ${dump_helpers_1.DumpHelpers.dumpType(this.type)};\n`;
     }

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

@@ -0,0 +1,6 @@
+import { Element } from './element';
+import { $Topic } from "../../elements/blocks/topic/topic.schema";
+export declare class TopicElement extends Element<$Topic> {
+    protected prepare(): void;
+    protected buildType(): any;
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopicElement = void 0;
+const element_1 = require("./element");
+const dump_helpers_1 = require("../helpers/dump_helpers");
+class TopicElement extends element_1.Element {
+    prepare() {
+        this.schema['#authn'] = element_1.Element.Any;
+        this.schema['#input'] = element_1.Element.Never;
+        this.schema['#output'] = element_1.Element.Any;
+    }
+    buildType() {
+        const { input } = element_1.Element.makeIOType(this.compiler, this.schema);
+        const type = dump_helpers_1.DumpHelpers.dumpValueToType(this.schema);
+        delete type['output'];
+        return {
+            '#authn': element_1.Element.makeAuthnType(this.schema.authn),
+            '#input': input,
+            '#output': input,
+            ...type,
+        };
+    }
+}
+exports.TopicElement = TopicElement;

package/lib/compiler/helpers/name_helpers.js

@@ -31,7 +31,8 @@ class NameHelpers {
             'resource': 'Resource',
             'machine': 'Machine',
             'controller': 'Controller',
-            'queue': 'Queue'
+            'queue': 'Queue',
+            'topic': 'Topic'
         }[schema.$t];
         const typeName = highName + suffix;
         return {

package/lib/compiler/module.d.ts

@@ -13,6 +13,7 @@ import { $Module } from "../schema";
 import { QueueElement } from './elements/queue.element';
 import { Element } from './elements/element';
 import { CachedElement } from './elements/cached.element';
+import { TopicElement } from './elements/topic.element';
 export declare class CompilerModule {
     compiler: Compiler;
     lowName: string;
@@ -21,5 +22,5 @@ export declare class CompilerModule {
     module: Module<any, $Module>;
     elements: Element<any>[];
     constructor(compiler: Compiler, name: string, path: string, subdir?: string[]);
-    buildElementNode(node: ResolvedBuilderNode): Promise<MessageElement | BucketElement | JobElement | ResourceElement | MachineElement | ControllerElement | ConstantsElement | ExternalsElement | QueueElement | CachedElement | undefined>;
+    buildElementNode(node: ResolvedBuilderNode): Promise<MessageElement | BucketElement | JobElement | ResourceElement | MachineElement | ControllerElement | ConstantsElement | ExternalsElement | QueueElement | CachedElement | TopicElement | undefined>;
 }

package/lib/compiler/module.js

@@ -49,6 +49,7 @@ const externals_element_1 = require("./elements/externals.element");
 const log_1 = require("../engine/util/log");
 const queue_element_1 = require("./elements/queue.element");
 const cached_element_1 = require("./elements/cached.element");
+const topic_element_1 = require("./elements/topic.element");
 class CompilerModule {
     constructor(compiler, name, path, subdir = []) {
         this.compiler = compiler;
@@ -124,6 +125,12 @@ class CompilerModule {
             this.elements.push(el);
             return el;
         }
+        if (node.type === 'topic') {
+            const schema = node.schema;
+            const el = new topic_element_1.TopicElement(this.compiler, this.lowName, 'topic', [node.filepath], schema, node.dependencies.map(dep => dep.node), undefined, node.bridge);
+            this.elements.push(el);
+            return el;
+        }
     }
 }
 exports.CompilerModule = CompilerModule;

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

@@ -135,7 +135,7 @@ class DumpStage {
         var _a, _b;
         const nesoiPath = this.compiler.config?.nesoiPath ?? 'nesoi';
         const moduleFile = [];
-        moduleFile.push(`import { $Module, $Constants, $Bucket, $Message, $Job, $Resource, $Machine, $Controller, $Queue } from '${nesoiPath}/lib/elements';`);
+        moduleFile.push(`import { $Module, $Constants, $Bucket, $Message, $Job, $Resource, $Machine, $Controller, $Queue, $Topic } from '${nesoiPath}/lib/elements';`);
         moduleFile.push(`import { NesoiDate } from '${nesoiPath}/lib/engine/data/date';`);
         moduleFile.push(`import { NesoiDatetime } from '${nesoiPath}/lib/engine/data/datetime';`);
         moduleFile.push(`import { NesoiDecimal } from '${nesoiPath}/lib/engine/data/decimal';`);
@@ -216,6 +216,7 @@ class DumpStage {
             resources: {},
             machines: {},
             queues: {},
+            topics: {},
             controllers: {},
         };
         // Merge types that currently exist and are found on cache
@@ -223,7 +224,7 @@ class DumpStage {
         if (typeCache) {
             type.externals = typeCache.externals || 'any';
             type.constants = typeCache.constants || 'any';
-            for (const eltype of ['buckets', 'messages', 'jobs', 'resources', 'machines', 'queues', 'controllers']) {
+            for (const eltype of ['buckets', 'messages', 'jobs', 'resources', 'machines', 'queues', 'topics', 'controllers']) {
                 for (const name in typeCache[eltype] || {}) {
                     if (name in module.module.schema[eltype]) {
                         type[eltype][name] = typeCache[eltype][name];

package/lib/compiler/treeshake.d.ts

@@ -32,6 +32,9 @@ export declare class Treeshake {
     static queue(node: BuilderNode): {
         inlines: BuilderNode[];
     };
+    static topic(node: BuilderNode): {
+        inlines: BuilderNode[];
+    };
     /**
      * Scans the module directory, imports the builders and lists
      * all nodes found.

package/lib/compiler/treeshake.js

@@ -208,6 +208,17 @@ class Treeshake {
         node.dependencies = this.cleanNodeDependencies(node);
         return { inlines: inlineTreeshake.inlines };
     }
+    static topic(node) {
+        const builder = node.builder;
+        log_1.Log.trace('compiler', 'treeshake', `└ Treeshaking node ${(0, log_1.scopeTag)(builder.$b, node.name)}`);
+        const inlineTreeshake = Treeshake.blockInlineNodes(node);
+        node.dependencies = [
+            ...Treeshake.blockIO(node),
+            ...inlineTreeshake.dependencies
+        ];
+        node.dependencies = this.cleanNodeDependencies(node);
+        return { inlines: inlineTreeshake.inlines };
+    }
     /* Module */
     /**
      * Scans the module directory, imports the builders and lists
@@ -374,6 +385,16 @@ class Treeshake {
                 });
             });
         }
+        else if (builder.$b === 'topic') {
+            const { inlines } = Treeshake.topic(node);
+            inlines.forEach(inline => {
+                nodes.push({
+                    ...inline,
+                    module,
+                    filepath
+                });
+            });
+        }
         else {
             throw error_1.NesoiError.Module.UnknownBuilderType({}, filepath, '', builder.$b);
         }

package/lib/compiler/typescript/typescript_compiler.js

@@ -464,6 +464,7 @@ class TypeScriptCompiler {
                 'machine',
                 'controller',
                 'queue',
+                'topic',
             ].includes(builderType)) {
                 throw new Error(`Unknown builder type ${builderType}`);
             }

package/lib/elements/blocks/block.schema.d.ts

@@ -2,7 +2,7 @@ import { TypeAsObj } from "../../compiler/elements/element";
 import { $Message } from "../entities/message/message.schema";
 import { AnyUsers } from "../../engine/auth/authn";
 import { $Dependency } from "../../engine/dependency";
-export type $BlockType = 'job' | 'resource' | 'machine' | 'queue';
+export type $BlockType = 'job' | 'resource' | 'machine' | 'queue' | 'topic';
 export type $BlockOutput = {
     raw?: TypeAsObj;
     msg?: $Dependency[];

package/lib/elements/blocks/topic/topic.builder.d.ts

@@ -0,0 +1,36 @@
+import { $Module, $Space, ScopedMessage, ScopedMessageName } from "../../../schema";
+import { $Topic } from './topic.schema';
+import { ResolvedBuilderNode } from "../../../engine/dependency";
+import { BlockBuilder } from '../block.builder';
+import { Overlay } from "../../../engine/util/type";
+import { MessageTemplateDef } from "../../entities/message/template/message_template.builder";
+import { $MessageInfer } from "../../entities/message/message.infer";
+import { ModuleTree } from "../../../engine/tree";
+import { $Message } from "../../entities/message/message.schema";
+/**
+ * @category Builders
+ * @subcategory Block
+ */
+export declare class TopicBuilder<Space extends $Space, Module extends $Module, Topic extends $Topic> extends BlockBuilder<Space, Module, 'topic'> {
+    $b: "topic";
+    constructor(module: string, name: string);
+    authn<U extends keyof Space['authnUsers']>(...providers: U[]): TopicBuilder<Space, Module, Overlay<Topic, {
+        "#authn": { [K in U]: Space["authnUsers"][U]; };
+    }>>;
+    message<Name extends string, Def extends MessageTemplateDef<Space, Module, Name>, FullName extends string = `${Topic['name']}${Name extends '' ? '' : '.'}${Name & string}`, Msg extends $Message = $MessageInfer<FullName, ($: any) => ReturnType<Def>>>(name: Name, def: Def): TopicBuilder<Space, Overlay<Module, {
+        messages: Overlay<Module["messages"], { [K in FullName]: Msg; }>;
+    }>, Topic>;
+    input<MsgName extends ScopedMessageName<Module, Topic['name']>, Msg extends NoInfer<ScopedMessage<Module, Topic['name'], MsgName>>, PreInput extends $Message = Topic['#input']['#raw']['$'] extends string ? Topic['#input'] : never>(...def: MsgName[]): TopicBuilder<Space, Module, Overlay<Topic, {
+        "#input": PreInput | Msg;
+        "#output": PreInput | Msg;
+    }>>;
+    static build(node: TopicBuilderNode, tree: ModuleTree, module: $Module): {
+        schema: $Topic;
+        inlineMessages: Record<string, $Message>;
+    };
+}
+export type AnyTopicBuilder = TopicBuilder<any, any, any>;
+export type TopicBuilderNode = Omit<ResolvedBuilderNode, 'builder'> & {
+    builder: AnyTopicBuilder;
+    schema?: $Topic;
+};

package/lib/elements/blocks/topic/topic.builder.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopicBuilder = void 0;
+const topic_schema_1 = require("./topic.schema");
+const block_builder_1 = require("../block.builder");
+const message_builder_1 = require("../../entities/message/message.builder");
+/**
+ * @category Builders
+ * @subcategory Block
+ */
+class TopicBuilder extends block_builder_1.BlockBuilder {
+    constructor(module, name) {
+        super(module, 'topic', name);
+        this.$b = 'topic';
+    }
+    /* [Block] */
+    authn(...providers) {
+        return super.authn(...providers);
+    }
+    /* [Topic] */
+    message(name, def) {
+        return super.message(name, def);
+    }
+    input(...def) {
+        return super._input(...def);
+    }
+    // Build
+    static build(node, tree, module) {
+        const input = node.builder._inputMsgs;
+        node.schema = new topic_schema_1.$Topic(node.builder.module, node.builder.name, node.builder._alias || node.builder.name, node.builder._authn, input, node.builder._output);
+        return {
+            schema: node.schema,
+            inlineMessages: message_builder_1.MessageBuilder.buildInlines(node, tree, module)
+        };
+    }
+}
+exports.TopicBuilder = TopicBuilder;

package/lib/elements/blocks/topic/topic.d.ts

@@ -0,0 +1,20 @@
+import { $Module, $Space } from "../../../schema";
+import { $Topic } from './topic.schema';
+import { Module } from "../../../engine/module";
+import { AnyMessage } from "../../entities/message/message";
+import { TrxNode } from "../../../engine/transaction/trx_node";
+import { Block } from '../block';
+export type TopicSubscription = {
+    id: string;
+    fn: (msg: AnyMessage) => void;
+};
+export declare class Topic<S extends $Space, M extends $Module, $ extends $Topic> extends Block<S, M, $> {
+    module: Module<any, M>;
+    schema: $;
+    private subscriptions;
+    constructor(module: Module<any, M>, schema: $);
+    protected run(trx: TrxNode<S, M, $['#authn']>, msg: AnyMessage, _ctx?: Record<string, any>): Promise<void>;
+    subscribe(trx: TrxNode<S, M, $['#authn']>, fn: (msg: AnyMessage) => void): string;
+    unsubscribe(trx: TrxNode<S, M, $['#authn']>, id: string): void;
+}
+export type AnyTopic = Topic<any, any, any>;

package/lib/elements/blocks/topic/topic.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Topic = void 0;
+const trx_node_1 = require("../../../engine/transaction/trx_node");
+const block_1 = require("../block");
+const crypto_1 = require("crypto");
+const log_1 = require("../../../engine/util/log");
+class Topic extends block_1.Block {
+    constructor(module, schema) {
+        super('topic', module, schema);
+        this.module = module;
+        this.schema = schema;
+        this.subscriptions = {};
+    }
+    // Publish
+    async run(trx, msg, _ctx = {}) {
+        // Check authentication
+        trx_node_1.TrxNode.checkAuthn(trx, this.schema.authn);
+        for (const id in this.subscriptions) {
+            try {
+                this.subscriptions[id].fn(msg);
+            }
+            catch (error) {
+                log_1.Log.error('topic', this.schema.name, `Subscription ${id} threw an error when executed. Removed.`, { error });
+                delete this.subscriptions[id];
+            }
+        }
+    }
+    subscribe(trx, fn) {
+        // Check authentication
+        trx_node_1.TrxNode.checkAuthn(trx, this.schema.authn);
+        const id = (0, crypto_1.randomUUID)();
+        this.subscriptions[id] = {
+            id, fn
+        };
+        return id;
+    }
+    unsubscribe(trx, id) {
+        // Check authentication
+        trx_node_1.TrxNode.checkAuthn(trx, this.schema.authn);
+        delete this.subscriptions[id];
+    }
+}
+exports.Topic = Topic;

package/lib/elements/blocks/topic/topic.schema.d.ts

@@ -0,0 +1,17 @@
+import { $Dependency } from "../../../engine/dependency";
+import { $Block, $BlockOutput } from '../block.schema';
+/**
+ * @category Schemas
+ * @subcategory Block
+ */
+export declare class $Topic extends $Block {
+    module: string;
+    name: string;
+    alias: string;
+    authn: string[];
+    input: $Dependency[];
+    output: $BlockOutput | undefined;
+    $t: "topic";
+    dependencies: $Dependency[];
+    constructor(module: string, name: string, alias: string, authn: string[], input: $Dependency[], output: $BlockOutput | undefined);
+}

package/lib/elements/blocks/topic/topic.schema.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$Topic = void 0;
+const block_schema_1 = require("../block.schema");
+/**
+ * @category Schemas
+ * @subcategory Block
+ */
+class $Topic extends block_schema_1.$Block {
+    constructor(module, name, alias, authn, input, output) {
+        super(module, name, alias, authn, input, output);
+        this.module = module;
+        this.name = name;
+        this.alias = alias;
+        this.authn = authn;
+        this.input = input;
+        this.output = output;
+        this.$t = 'topic';
+        this.dependencies = [];
+    }
+}
+exports.$Topic = $Topic;

package/lib/elements/edge/controller/adapters/cli.controller_adapter.d.ts

@@ -1,6 +1,6 @@
 import { ControllerAdapter } from './controller_adapter';
-import { ControllerEndpoint } from '../controller';
-import { $ControllerDomain, $ControllerEndpoint, $ControllerGroup } from '../controller.schema';
+import { ControllerEndpoint, ControllerTopic } from '../controller';
+import { $ControllerDomain, $ControllerEndpoint, $ControllerGroup, $ControllerTopic } from '../controller.schema';
 export type ControllerEndpointPath = ($ControllerDomain | $ControllerGroup | $ControllerEndpoint)[];
 /**
  * @category Adapters
@@ -8,5 +8,7 @@ export type ControllerEndpointPath = ($ControllerDomain | $ControllerGroup | $Co
  */
 export declare class CLIControllerAdapter extends ControllerAdapter {
     endpoints: Record<string, ControllerEndpoint<$ControllerEndpoint>>;
+    topics: Record<string, ControllerTopic<$ControllerTopic>>;
     protected makeEndpoint(path: string, schema: $ControllerEndpoint): void;
+    protected makeTopic(schema: $ControllerTopic): void;
 }

package/lib/elements/edge/controller/adapters/cli.controller_adapter.js

@@ -12,10 +12,15 @@ class CLIControllerAdapter extends controller_adapter_1.ControllerAdapter {
     constructor() {
         super(...arguments);
         this.endpoints = {};
+        this.topics = {};
     }
     makeEndpoint(path, schema) {
         this.endpoints[path] = new controller_1.ControllerEndpoint(schema, this, path);
         log_1.Log.debug('controller', this.schema.name, `Bound endpoint '${path}' to '${schema.target.tag}'`);
     }
+    makeTopic(schema) {
+        this.topics[schema.name] = new controller_1.ControllerTopic(schema, this, schema.name);
+        log_1.Log.debug('controller', this.schema.name, `Bound topic '${schema.name}'`);
+    }
 }
 exports.CLIControllerAdapter = CLIControllerAdapter;

package/lib/elements/edge/controller/adapters/controller_adapter.d.ts

@@ -1,5 +1,5 @@
 import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
-import { $Controller, $ControllerDomain, $ControllerEndpoint, $ControllerGroup } from '../controller.schema';
+import { $Controller, $ControllerDomain, $ControllerEndpoint, $ControllerGroup, $ControllerTopic } from '../controller.schema';
 import { AnyDaemon } from "../../../../engine/daemon";
 import { AuthnRequest } from "../../../../engine/auth/authn";
 import { $Module } from "../../..";
@@ -16,6 +16,7 @@ export declare abstract class ControllerAdapter {
     trx(fn: (trx: AnyTrxNode) => Promise<any>, authn?: AuthnRequest<any>): Promise<import("../../../../engine/transaction/trx").TrxStatus<any>>;
     bind(daemon: AnyDaemon): void;
     protected abstract makeEndpoint(path: string, schema: $ControllerEndpoint): void;
+    protected abstract makeTopic(schema: $ControllerTopic): void;
     protected makeGroup(group: $ControllerGroup, root?: ControllerEndpointPath): void;
     protected makePath(schema: $Controller, path: ControllerEndpointPath): string;
 }

package/lib/elements/edge/controller/adapters/controller_adapter.js

@@ -31,6 +31,10 @@ class ControllerAdapter {
             const domain = this.schema.domains[d];
             this.makeGroup(domain, [domain]);
         }
+        for (const t in this.schema.topics) {
+            const topic = this.schema.topics[t];
+            this.makeTopic(topic);
+        }
     }
     makeGroup(group, root = []) {
         for (const e in group.endpoints) {

package/lib/elements/edge/controller/controller.builder.d.ts

@@ -1,7 +1,8 @@
 import { $Module, $Space } from "../../../schema";
-import { $Controller, $ControllerDomain, $ControllerEndpoint, $ControllerGroup } from './controller.schema';
+import { $Controller, $ControllerDomain, $ControllerEndpoint, $ControllerGroup, $ControllerTopic } from './controller.schema';
 import { $Message } from "../../entities/message/message.schema";
 import { $Dependency, ResolvedBuilderNode } from "../../../engine/dependency";
+import { $Topic } from "../../blocks/topic/topic.schema";
 type JobsSupportingMsg<M extends $Module, Msg extends $Message> = {
     [J in keyof M['jobs']]: Msg extends M['jobs'][J]['#input'] ? J : never;
 }[keyof M['jobs']];
@@ -34,6 +35,23 @@ export declare class ControllerEndpointBuilder<S extends $Space, M extends $Modu
     toMachine(machine: MachinesSupportingMsg<M, Msg>): this;
     static build(builder: ControllerEndpointBuilder<any, any>): $ControllerEndpoint;
 }
+/**
+ * @category Builders
+ * @subcategory Edge
+ */
+export declare class ControllerTopicBuilder<S extends $Space, Topic extends $Topic> {
+    private module;
+    private topic;
+    private _authn;
+    private _alias?;
+    private _tags;
+    private _msgs;
+    constructor(module: string, topic: $Dependency, _authn?: string[]);
+    as(alias: string): this;
+    authn<U extends keyof S['authnUsers']>(providers: U | U[]): this;
+    msg(name: Topic['#input']['#raw']['$']): this;
+    static build(builder: ControllerTopicBuilder<any, any>): $ControllerTopic;
+}
 /**
  * @category Builders
  * @subcategory Edge
@@ -74,16 +92,20 @@ export declare class ControllerBuilder<S extends $Space, M extends $Module> {
     private _alias?;
     private _authn;
     private domains;
+    protected topics: Record<string, ControllerTopicBuilder<any, any>>;
     constructor(module: string, name: string);
     as(alias: string): this;
     authn<U extends keyof S['authnUsers']>(providers: U | U[]): this;
     domain(name: string, $: ControllerDomainDef<S, M>): this;
+    topic<T extends keyof M['topics']>(name: T, $: ControllerTopicDef<S, M['topics'][T]>): this;
     static build(node: ControllerBuilderNode): $Controller;
     static buildInput(group: $ControllerGroup): $Dependency[];
     static buildDomains(builders: Record<string, ControllerDomainBuilder<any, any>>): Record<string, $ControllerDomain>;
+    static buildTopics(builders: Record<string, ControllerTopicBuilder<any, any>>): Record<string, $ControllerTopic>;
 }
 type ControllerEndpointDef<S extends $Space, M extends $Module> = ($: ControllerEndpointBuilder<S, M>) => ControllerEndpointBuilder<S, M, any>;
 type ControllerGroupDef<S extends $Space, M extends $Module> = ($: ControllerGroupBuilder<S, M>) => ControllerGroupBuilder<S, M>;
+type ControllerTopicDef<S extends $Space, T extends $Topic> = ($: ControllerTopicBuilder<S, T>) => ControllerTopicBuilder<S, T>;
 type ControllerDomainDef<S extends $Space, M extends $Module> = ($: ControllerDomainBuilder<S, M>) => ControllerDomainBuilder<S, M>;
 export type AnyControllerBuilder = ControllerBuilder<any, any>;
 export type ControllerBuilderNode = Omit<ResolvedBuilderNode, 'builder'> & {

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ControllerBuilder = exports.ControllerDomainBuilder = exports.ControllerGroupBuilder = exports.ControllerEndpointBuilder = void 0;
+exports.ControllerBuilder = exports.ControllerDomainBuilder = exports.ControllerGroupBuilder = exports.ControllerTopicBuilder = exports.ControllerEndpointBuilder = void 0;
 const controller_schema_1 = require("./controller.schema");
 const dependency_1 = require("../../../engine/dependency");
 /**
@@ -54,6 +54,38 @@ class ControllerEndpointBuilder {
     }
 }
 exports.ControllerEndpointBuilder = ControllerEndpointBuilder;
+/**
+ * @category Builders
+ * @subcategory Edge
+ */
+class ControllerTopicBuilder {
+    constructor(module, topic, _authn = []) {
+        this.module = module;
+        this.topic = topic;
+        this._authn = _authn;
+        this._tags = [];
+        this._msgs = [];
+    }
+    as(alias) {
+        this._alias = alias;
+        return this;
+    }
+    authn(providers) {
+        if (!Array.isArray(providers)) {
+            providers = [providers];
+        }
+        this._authn = providers;
+        return this;
+    }
+    msg(name) {
+        this._msgs.push(new dependency_1.$Dependency(this.module, 'message', name));
+        return this;
+    }
+    static build(builder) {
+        return new controller_schema_1.$ControllerTopic(builder.topic.name, builder._alias || builder.topic.name, builder._authn, builder._tags, builder._msgs, builder.topic);
+    }
+}
+exports.ControllerTopicBuilder = ControllerTopicBuilder;
 /**
  * @category Builders
  * @subcategory Edge
@@ -142,6 +174,7 @@ class ControllerBuilder {
         this.$b = 'controller';
         this._authn = [];
         this.domains = {};
+        this.topics = {};
     }
     as(alias) {
         this._alias = alias;
@@ -161,13 +194,21 @@ class ControllerBuilder {
         this.domains[name + '.' + version] = builder;
         return this;
     }
+    topic(name, $) {
+        const topic = new dependency_1.$Dependency(this.module, 'topic', name);
+        const builder = new ControllerTopicBuilder(this.module, topic, this._authn);
+        $(builder);
+        this.topics[name] = builder;
+        return this;
+    }
     // Build
     static build(node) {
         const domains = this.buildDomains(node.builder.domains);
+        const topics = this.buildTopics(node.builder.topics);
         const input = Object.values(domains)
             .map(domain => this.buildInput(domain))
             .flat();
-        node.schema = new controller_schema_1.$Controller(node.module, node.builder.name, node.builder._alias || node.builder.name, node.builder._authn, input, domains);
+        node.schema = new controller_schema_1.$Controller(node.module, node.builder.name, node.builder._alias || node.builder.name, node.builder._authn, input, domains, topics);
         return node.schema;
     }
     static buildInput(group) {
@@ -190,5 +231,13 @@ class ControllerBuilder {
         }
         return domains;
     }
+    static buildTopics(builders) {
+        const topics = {};
+        for (const g in builders) {
+            const topic = builders[g];
+            topics[g] = ControllerTopicBuilder.build(topic);
+        }
+        return topics;
+    }
 }
 exports.ControllerBuilder = ControllerBuilder;

package/lib/elements/edge/controller/controller.d.ts

@@ -1,10 +1,11 @@
 import { $Module, $Space } from "../../../schema";
 import { Module } from "../../../engine/module";
-import { $Controller, $ControllerEndpoint } from './controller.schema';
+import { $Controller, $ControllerEndpoint, $ControllerTopic } from './controller.schema';
 import { ControllerAdapter } from './adapters/controller_adapter';
 import { ControllerConfig } from './controller.config';
 import { AnyDaemon } from "../../../engine/daemon";
 import { AuthnRequest } from "../../../engine/auth/authn";
+import { AnyMessage } from "../../entities/message/message";
 /**
  * @category Elements
  * @subcategory Edge
@@ -16,6 +17,18 @@ export declare class ControllerEndpoint<$ extends $ControllerEndpoint> {
     constructor(schema: $, adapter: ControllerAdapter, path: string);
     invoke(data: Record<string, any>, authn?: AuthnRequest<any>): Promise<import("../../../engine/transaction/trx").TrxStatus<any>>;
 }
+/**
+ * @category Elements
+ * @subcategory Edge
+ */
+export declare class ControllerTopic<$ extends $ControllerTopic> {
+    schema: $;
+    adapter: ControllerAdapter;
+    path: string;
+    constructor(schema: $, adapter: ControllerAdapter, path: string);
+    subscribe(fn: (msg: AnyMessage) => void, authn?: AuthnRequest<any>): Promise<string>;
+    unsubscribe(id: string): Promise<string>;
+}
 export declare class Controller<S extends $Space, M extends $Module, $ extends $Controller> {
     schema: $;
     config?: ControllerConfig<M, $, any> | undefined;