nesoi 3.4.22 → 3.4.24

package/lib/bundler/browser/browser.bundler.js

@@ -17,7 +17,7 @@ class BrowserBundler extends monolyth_bundler_1.MonolythBundler {
     async run() {
         await super.run();
         console_1.default.header('Browser Bundler');
-        log_1.Log.info('bundler', 'browser', `Importing the monolyth definition from ${this.appPath}`);
+        log_1.Log.info('bundler', 'browser', `Importing the monolyth definition from ${this.compiler.appPath}`);
         await new _8_replace_nesoi_for_browser_stage_1.ReplaceNesoiForBrowserStage(this).run();
     }
 }

package/lib/bundler/monolyth/monolyth.bundler.d.ts

@@ -4,16 +4,16 @@ import type { MonolythBundlerConfig } from "../../engine/app/native/monolyth.app
 import { MonolythApp } from "../../engine/app/native/monolyth.app";
 export declare class MonolythBundler {
     compiler: Compiler;
-    appPath: string;
     config: MonolythBundlerConfig;
     tsconfig: Record<string, string | number>;
     dirs: {
+        dot_nesoi: string;
         build: string;
         build_modules: string;
         build_types: string;
         build_bin: string;
     };
-    constructor(compiler: Compiler, appPath: string, config?: MonolythBundlerConfig);
+    constructor(compiler: Compiler, config?: MonolythBundlerConfig);
     run(): Promise<void>;
     mergeServicePaths(app: AnyApp): void;
     expandLibPaths(): void;

package/lib/bundler/monolyth/monolyth.bundler.js

@@ -54,20 +54,23 @@ const monolyth_app_1 = require("../../engine/app/native/monolyth.app");
 const path_1 = require("../../engine/util/path");
 class MonolythBundler {
     compiler;
-    appPath;
     config;
     tsconfig = {};
     dirs;
-    constructor(compiler, appPath, config = {}) {
+    constructor(compiler, config = {}) {
         this.compiler = compiler;
-        this.appPath = appPath;
         this.config = config;
-        this.dirs = {};
+        this.dirs = {
+            dot_nesoi: space_1.Space.path(this.compiler.space, '.nesoi', this.compiler.targetDir)
+        };
     }
     async run() {
         console_1.default.header('Monolyth Bundler');
-        log_1.Log.info('bundler', 'monolyth', `Importing the monolyth definition from ${this.appPath}`);
-        const appFile = space_1.Space.path(this.compiler.space, this.appPath);
+        if (!this.compiler.appPath) {
+            throw new Error('The compiler passed as argument to the bundler MUST include some app as argument.');
+        }
+        log_1.Log.info('bundler', 'monolyth', `Importing the monolyth definition from ${this.compiler.appPath}`);
+        const appFile = space_1.Space.path(this.compiler.space, this.compiler.appPath);
         const app = (await Promise.resolve(`${appFile}`).then(s => __importStar(require(s)))).default;
         this.config = Object.assign({}, app_1.App.getInfo(app).config?.compiler || {}, this.config);
         this.mergeServicePaths(app);

package/lib/bundler/monolyth/stages/2_build_typescript_stage.js

@@ -56,7 +56,7 @@ class BuildTypescriptStage {
     }
     async run() {
         log_1.Log.info('compiler', 'monolyth', 'Building TypeScript files...');
-        const { config, compiler, dirs, appPath } = this.bundler;
+        const { config, compiler, dirs } = this.bundler;
         const libPaths = (config.libPaths || []).map(path => {
             return space_1.Space.path(compiler.space, path);
         });
@@ -67,13 +67,13 @@ class BuildTypescriptStage {
         const modulePaths = [];
         space_1.Space.scan(compiler.space, (name) => {
             if (info.spaceModules.includes(name)) {
-                modulePaths.push(space_1.Space.path(compiler.space, '.nesoi', name));
+                modulePaths.push(path.join(dirs.dot_nesoi, name));
             }
         });
         const space = compiler.space;
         const spacePath = space_1.Space.path(space);
         const libFiles = typescript_compiler_1.TypeScriptCompiler.allFiles(libPaths);
-        const appFile = space_1.Space.path(space, appPath);
+        const appFile = space_1.Space.path(space, compiler.appPath);
         const nesoiFile = space_1.Space.path(space, 'nesoi.ts');
         const moduleFiles = typescript_compiler_1.TypeScriptCompiler.allFiles(modulePaths);
         const replacePaths = {
@@ -128,10 +128,9 @@ class BuildTypescriptStage {
             replacePaths[lib] = path.resolve(dirs.build, outPath);
             tsPaths[lib + '/*'] = [space_1.Space.path(compiler.space, lib) + '/*'];
         });
-        tsPaths['.nesoi/*'] = [space_1.Space.path(compiler.space, '.nesoi') + '/*'];
-        const dotNesoiPath = space_1.Space.path(compiler.space, '.nesoi');
+        tsPaths['.nesoi/*'] = [path.join(dirs.dot_nesoi, '*')];
         moduleFiles.forEach(moduleFile => {
-            const module = moduleFile.replace(dotNesoiPath, '').split(path.sep)[1];
+            const module = moduleFile.replace(dirs.dot_nesoi, '').split(path.sep)[1];
             if (!module?.length) {
                 throw new Error(`Unable to find module name from path ${moduleFile}`);
             }

package/lib/bundler/monolyth/stages/3_copy_types_stage.js

@@ -36,7 +36,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CopyTypesStage = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const space_1 = require("../../../engine/space");
 const log_1 = require("../../../engine/util/log");
 const name_helpers_1 = require("../../../engine/util/name_helpers");
 const app_1 = require("../../../engine/app/app");
@@ -61,7 +60,7 @@ class CopyTypesStage {
         // Copy module types to types folder
         for (const name of info.spaceModules) {
             const module = compiler.modules[name];
-            const from = space_1.Space.path(compiler.space, '.nesoi', module.lowName + '.module.ts');
+            const from = path.join(dirs.dot_nesoi, module.lowName + '.module.ts');
             const to = path.resolve(dirs.build_types, module.lowName + '.module.ts');
             log_1.Log.debug('compiler', 'monolyth', `Copying module types from ${from} to ${to}`);
             fs.cpSync(from, to, { recursive: true });
@@ -70,7 +69,7 @@ class CopyTypesStage {
         {
             const space = compiler.space._name;
             const spaceLow = name_helpers_1.NameHelpers.nameHighToLow(space);
-            const from = space_1.Space.path(compiler.space, '.nesoi', spaceLow + '.ts');
+            const from = path.join(dirs.dot_nesoi, spaceLow + '.ts');
             const to = path.resolve(dirs.build_types, spaceLow + '.ts');
             log_1.Log.debug('compiler', 'monolyth', `Copying space types from ${from} to ${to}`);
             fs.cpSync(from, to, { recursive: true });

package/lib/compiler/compiler.d.ts

@@ -4,13 +4,22 @@ import type { CompilerConfig } from "../engine/app/app.config";
 import { ModuleTree } from "../engine/tree";
 import { Space } from "../engine/space";
 import { TypeScriptCompiler } from './typescript/typescript_compiler';
+import type { Tag } from "../engine/dependency";
 export declare class Compiler {
     space: Space<$Space>;
     config?: CompilerConfig | undefined;
+    appPath?: string | undefined;
     modules: Record<string, CompilerModule>;
     tree: ModuleTree;
     tsCompiler: TypeScriptCompiler;
+    targetDir: string;
     logFn?: (msg: string) => void;
-    constructor(space: Space<$Space>, config?: CompilerConfig | undefined);
+    tags?: {
+        [module: string]: {
+            include?: Tag[];
+            exclude?: Tag[];
+        };
+    };
+    constructor(space: Space<$Space>, config?: CompilerConfig | undefined, appPath?: string | undefined);
     run(): Promise<this>;
 }

package/lib/compiler/compiler.js

@@ -1,9 +1,43 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Compiler = void 0;
+const app_1 = require("../engine/app/app");
 const tree_1 = require("../engine/tree");
 const space_1 = require("../engine/space");
 const typescript_compiler_1 = require("./typescript/typescript_compiler");
@@ -21,22 +55,37 @@ const fs_1 = __importDefault(require("fs"));
 class Compiler {
     space;
     config;
+    appPath;
     modules = {};
     tree;
     tsCompiler;
+    targetDir;
     logFn;
-    constructor(space, config) {
+    tags;
+    constructor(space, config, appPath) {
         this.space = space;
         this.config = config;
+        this.appPath = appPath;
         console_1.default.header('Compiler');
-        log_1.Log.info('compiler', 'ts', 'Loading TypeScript...');
-        this.tree = new tree_1.ModuleTree({}, this.config);
+        log_1.Log.info('compiler', 'ts', 'Preparing TypeScript...');
         this.tsCompiler = new typescript_compiler_1.TypeScriptCompiler(space, config?.nesoiPath);
     }
     async run() {
-        if (this.config?.reset) {
+        let app;
+        if (this.appPath) {
+            log_1.Log.info('compiler', 'ts', `Importing the app definition from ${this.appPath}`);
+            const appFile = space_1.Space.path(this.space, this.appPath);
+            app = (await Promise.resolve(`${appFile}`).then(s => __importStar(require(s)))).default;
+        }
+        this.tags = app ? app_1.App.getIncludeExcludeTags(app) : undefined;
+        log_1.Log.info('compiler', 'ts', 'Starting');
+        this.tree = new tree_1.ModuleTree({}, {
+            exclude: this.config?.exclude
+        });
+        this.targetDir = app ? `.app.${app.name}` : '';
+        if (this.appPath || this.config?.reset) {
             // Cleanup .nesoi folder
-            fs_1.default.rmSync(space_1.Space.path(this.space, '.nesoi'), { recursive: true, force: true });
+            fs_1.default.rmSync(space_1.Space.path(this.space, '.nesoi', this.targetDir), { recursive: true, force: true });
         }
         try {
             await new _1_scan_stage_1.ScanStage(this).run();

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

@@ -1,4 +1,4 @@
-import type { $Controller } from "../../elements/edge/controller/controller.schema";
+import { $Controller } from "../../elements/edge/controller/controller.schema";
 import { Element } from './element';
 export declare class ControllerElement extends Element<$Controller> {
     protected prepare(): void;

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ControllerElement = void 0;
+const controller_schema_1 = require("../../elements/edge/controller/controller.schema");
 const element_1 = require("./element");
 const dump_helpers_1 = require("../helpers/dump_helpers");
 const name_helpers_1 = require("../../engine/util/name_helpers");
@@ -8,14 +9,21 @@ class ControllerElement extends element_1.Element {
     prepare() {
         this.schema['#authn'] = element_1.Element.Any;
         this.schema['#input'] = element_1.Element.Any;
+        this.schema['#path'] = element_1.Element.Any;
     }
     buildType() {
         const type = dump_helpers_1.DumpHelpers.dumpValueToType(this.schema);
         const input = this.schema.input.map(tag => name_helpers_1.NameHelpers.tagType(tag, this.module)).join(' | ');
+        const endpoints = controller_schema_1.$Controller.endpoints(this.schema);
+        const path = Object.fromEntries(Object.entries(endpoints).map(p => [
+            p[0],
+            name_helpers_1.NameHelpers.tagType(p[1].endpoint.msg, this.module)
+        ]));
         return {
             ...type,
             '#authn': element_1.Element.makeAuthnType(this.schema.auth),
             '#input': input,
+            '#path': path
         };
     }
 }

package/lib/compiler/progressive.js

@@ -45,7 +45,7 @@ const hash_1 = require("../engine/util/hash");
 const path_1 = __importDefault(require("path"));
 class ProgressiveBuild {
     static cache(compiler, $) {
-        const path = space_1.Space.path(compiler.space, '.nesoi', '.cache');
+        const path = space_1.Space.path(compiler.space, '.nesoi', compiler.targetDir, '.cache');
         if (!(0, fs_1.existsSync)(path)) {
             return this.init(compiler);
         }
@@ -85,7 +85,7 @@ class ProgressiveBuild {
     }
     static async init(compiler) {
         const cache = {
-            nesoidir: space_1.Space.path(compiler.space, '.nesoi'),
+            nesoidir: space_1.Space.path(compiler.space, '.nesoi', compiler.targetDir),
             hash: await ProgressiveBuild.hash(compiler),
             files: {},
             modules: {},

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

@@ -41,7 +41,7 @@ class BuildSchemasStage {
             if (node.isInline) {
                 return;
             }
-            await builder_1.Builder.buildNode(module, node, this.compiler.tree);
+            await builder_1.Builder.buildNode(module, node, this.compiler.tree, this.compiler.tags);
         });
         const t = new Date().getTime();
         log_1.Log.debug('compiler', 'stage.build_schemas', `[t: ${(t - t0) / 1000} ms]`);

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

@@ -21,6 +21,8 @@ class InjectTSStage {
         const { tree } = this.compiler;
         const nodes = tree.allNodes();
         tree.traverse('inject', node => {
+            if (node.filtered)
+                return Promise.resolve();
             inject_1.TSBridgeInject.inject(this.compiler, nodes, node);
             return Promise.resolve();
         });

package/lib/compiler/stages/6_build_elements_stage.js

@@ -19,6 +19,8 @@ class BuildElementsStage {
         log_1.Log.info('compiler', 'stage.build_elements', 'Building Elements...');
         const t0 = new Date().getTime();
         await this.compiler.tree.traverse('Building elements ', async (node) => {
+            if (node.filtered)
+                return;
             const module = this.compiler.modules[node.tag.module];
             await module.buildElementNode(node);
         });

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

@@ -127,7 +127,8 @@ class DumpStage {
         dump += `\nexport default interface ${name} extends $Space `;
         dump += dump_helpers_1.DumpHelpers.dumpType(type);
         // Create dir and write to file
-        const dumpDir = space_1.Space.path(this.compiler.space, './.nesoi');
+        const targetPath = path_1.default.join('.', '.nesoi', this.compiler.targetDir);
+        const dumpDir = space_1.Space.path(this.compiler.space, targetPath);
         if (!fs.existsSync(dumpDir)) {
             fs.mkdirSync(dumpDir, { recursive: true });
         }
@@ -137,7 +138,8 @@ class DumpStage {
     }
     /* Module */
     dumpModule(module, spaceType) {
-        const dumpDir = space_1.Space.path(this.compiler.space, `./.nesoi/${module.lowName}`);
+        const targetPath = path_1.default.join('.', '.nesoi', this.compiler.targetDir, module.lowName);
+        const dumpDir = space_1.Space.path(this.compiler.space, targetPath);
         if (!fs.existsSync(dumpDir)) {
             fs.mkdirSync(dumpDir, { recursive: true });
         }

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

@@ -1,14 +1,11 @@
-import type { $ControllerDomain, $ControllerEndpoint, $ControllerGroup, $ControllerTopic } from '../controller.schema';
+import { type $ControllerEndpoint, type $ControllerTopic } from '../controller.schema';
 import { ControllerAdapter } from './controller_adapter';
 import { ControllerEndpoint, ControllerTopic } from '../controller';
-export type ControllerEndpointPath = ($ControllerDomain | $ControllerGroup | $ControllerEndpoint)[];
 /**
  * @category Adapters
  * @subcategory Edge
  */
 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;
+    protected makeEndpoint(path: string, schema: $ControllerEndpoint): ControllerEndpoint<$ControllerEndpoint>;
+    protected makeTopic(schema: $ControllerTopic): ControllerTopic<$ControllerTopic>;
 }

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

@@ -9,15 +9,15 @@ const log_1 = require("../../../../engine/util/log");
  * @subcategory Edge
  */
 class CLIControllerAdapter extends controller_adapter_1.ControllerAdapter {
-    endpoints = {};
-    topics = {};
     makeEndpoint(path, schema) {
-        this.endpoints[path] = new controller_1.ControllerEndpoint(schema, this, path);
+        const endpoint = new controller_1.ControllerEndpoint(schema, this, path);
         log_1.Log.debug('controller', this.schema.name, `Bound endpoint '${path}' to '${schema.target}'`);
+        return endpoint;
     }
     makeTopic(schema) {
-        this.topics[schema.name] = new controller_1.ControllerTopic(schema, this, schema.name);
+        const topic = new controller_1.ControllerTopic(schema, this, schema.name);
         log_1.Log.debug('controller', this.schema.name, `Bound topic '${schema.name}'`);
+        return topic;
     }
 }
 exports.CLIControllerAdapter = CLIControllerAdapter;

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

@@ -1,9 +1,10 @@
 import type { AnyTrxNode } from "../../../../engine/transaction/trx_node";
-import type { $Controller, $ControllerDomain, $ControllerEndpoint, $ControllerGroup, $ControllerTopic } from '../controller.schema';
+import type { $ControllerEndpoint, $ControllerTopic, ControllerEndpointPath } from '../controller.schema';
+import { $Controller } from '../controller.schema';
 import type { AnyDaemon } from "../../../../engine/daemon";
 import type { AuthRequest } from "../../../../engine/auth/authn";
 import type { $Module } from "../../..";
-export type ControllerEndpointPath = ($ControllerDomain | $ControllerGroup | $ControllerEndpoint)[];
+import type { ControllerEndpoint, ControllerTopic } from '../controller';
 /**
  * @category Adapters
  * @subcategory Edge
@@ -12,14 +13,23 @@ export declare abstract class ControllerAdapter {
     protected module: $Module;
     protected schema: $Controller;
     protected daemon?: AnyDaemon;
+    protected endpoints: {
+        [path_str: string]: {
+            path: ControllerEndpointPath;
+            endpoint: ControllerEndpoint<$ControllerEndpoint>;
+        };
+    };
+    protected topics: {
+        [path: string]: ControllerTopic<$ControllerTopic>;
+    };
     constructor(module: $Module, schema: $Controller);
     trx(fn: (trx: AnyTrxNode) => Promise<any>, endpoint: {
         name: string;
         idempotent?: boolean;
     }, auth?: AuthRequest<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;
+    invoke(path: string, data: Record<string, any>, auth?: AuthRequest<any>): Promise<import("../../../../engine/transaction/trx").TrxStatus<any>>;
+    protected makePath(path: ControllerEndpointPath, endpoint: $ControllerEndpoint): string;
+    protected abstract makeEndpoint(path: string, schema: $ControllerEndpoint): ControllerEndpoint<$ControllerEndpoint>;
+    protected abstract makeTopic(schema: $ControllerTopic): ControllerTopic<$ControllerTopic>;
 }

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

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ControllerAdapter = void 0;
+const controller_schema_1 = require("../controller.schema");
 const log_1 = require("../../../../engine/util/log");
+const error_1 = require("../../../../engine/data/error");
 /**
  * @category Adapters
  * @subcategory Edge
@@ -10,6 +12,8 @@ class ControllerAdapter {
     module;
     schema;
     daemon;
+    endpoints = {};
+    topics = {};
     constructor(module, schema) {
         this.module = module;
         this.schema = schema;
@@ -31,36 +35,29 @@ class ControllerAdapter {
     }
     bind(daemon) {
         this.daemon = daemon;
-        for (const d in this.schema.domains) {
-            const domain = this.schema.domains[d];
-            this.makeGroup(domain, [domain]);
+        const endpoints = controller_schema_1.$Controller.endpoints(this.schema);
+        for (const key in endpoints) {
+            const { endpoint, path } = endpoints[key];
+            const path_str = this.makePath(path, endpoint);
+            this.endpoints[key] = {
+                path,
+                endpoint: this.makeEndpoint(path_str, endpoint)
+            };
         }
         for (const t in this.schema.topics) {
             const topic = this.schema.topics[t];
-            this.makeTopic(topic);
+            this.topics[t] = this.makeTopic(topic);
         }
     }
-    makeGroup(group, root = []) {
-        for (const e in group.endpoints) {
-            const endpoint = group.endpoints[e];
-            const path = this.makePath(this.schema, [...root, endpoint]);
-            this.makeEndpoint(path, endpoint);
-        }
-        for (const e in group.groups) {
-            const childGroup = group.groups[e];
-            const childRoot = [...root, childGroup];
-            this.makeGroup(childGroup, childRoot);
+    invoke(path, data, auth) {
+        const e = this.endpoints[path];
+        if (!e) {
+            throw error_1.NesoiError.Controller.EndpointNotFound({ endpoint: path, controller: this.schema.alias });
         }
+        return e.endpoint.invoke(data, auth);
     }
-    makePath(schema, path) {
-        const domain = path[0];
-        const root = domain.name
-            ? [schema.name, domain.name, domain.version]
-            : [schema.name, domain.version];
-        const list = root.concat(path
-            .slice(1)
-            .map(node => node.name));
-        return '/' + list.join('/');
+    makePath(path, endpoint) {
+        return controller_schema_1.$Controller.makePath(this.schema, path, endpoint);
     }
 }
 exports.ControllerAdapter = ControllerAdapter;

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

@@ -0,0 +1,27 @@
+import type { $Controller, $ControllerEndpoint, $ControllerTopic, ControllerEndpointPath } from '../controller.schema';
+import { ControllerAdapter } from './controller_adapter';
+import { ControllerEndpoint, ControllerTopic } from '../controller';
+import type { $Module } from "../../..";
+import type { AuthRequest } from "../../../../engine/auth/authn";
+import { TrxStatus } from "../../../../engine/transaction/trx";
+/**
+ * @category Adapters
+ * @subcategory Edge
+ */
+export declare class FetchControllerAdapter extends ControllerAdapter {
+    protected config: {
+        base_url: string;
+    };
+    constructor(module: $Module, schema: $Controller, config: {
+        base_url: string;
+    });
+    protected makeEndpoint(path: string, schema: $ControllerEndpoint): ControllerEndpoint<$ControllerEndpoint>;
+    protected makeTopic(schema: $ControllerTopic): ControllerTopic<$ControllerTopic>;
+    invoke(path: string, data: Record<string, any>, auth?: AuthRequest<any>): Promise<TrxStatus<{
+        data: Record<string, any> | Record<string, any>[];
+    }> | TrxStatus<undefined>>;
+    protected makeApiPath(endpoint: {
+        path: ControllerEndpointPath;
+        endpoint: ControllerEndpoint<any>;
+    }): string;
+}

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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchControllerAdapter = void 0;
+const controller_adapter_1 = require("./controller_adapter");
+const controller_1 = require("../controller");
+const log_1 = require("../../../../engine/util/log");
+const error_1 = require("../../../../engine/data/error");
+const trx_1 = require("../../../../engine/transaction/trx");
+const datetime_1 = require("../../../../engine/data/datetime");
+/**
+ * @category Adapters
+ * @subcategory Edge
+ */
+class FetchControllerAdapter extends controller_adapter_1.ControllerAdapter {
+    config;
+    constructor(module, schema, config) {
+        super(module, schema);
+        this.config = config;
+    }
+    makeEndpoint(path, schema) {
+        const endpoint = new controller_1.ControllerEndpoint(schema, this, path);
+        log_1.Log.debug('controller', this.schema.name, `Bound endpoint '${path}' to '${schema.target}'`);
+        return endpoint;
+    }
+    makeTopic(schema) {
+        const topic = new controller_1.ControllerTopic(schema, this, schema.name);
+        log_1.Log.debug('controller', this.schema.name, `Bound topic '${schema.name}'`);
+        return topic;
+    }
+    async invoke(path, data, auth) {
+        const endpoint = this.endpoints[path];
+        if (!endpoint) {
+            throw error_1.NesoiError.Controller.EndpointNotFound({ endpoint: path, controller: this.schema.alias });
+        }
+        const start = datetime_1.NesoiDatetime.now();
+        const url = this.config.base_url + this.makeApiPath(endpoint);
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(data)
+            })
+                .then(async (response) => ({
+                status: response.status,
+                headers: response.headers,
+                body: await response.json().catch(() => null)
+            }))
+                .then((response) => {
+                // if (response.status === 401) {
+                //     // ...
+                // }
+                return response.body;
+            })
+                .catch((e) => {
+                log_1.Log.error('controller', 'fetch', e.toString(), e);
+                // ...
+                throw e;
+            });
+            const end = datetime_1.NesoiDatetime.now();
+            return new trx_1.TrxStatus('#', 'plugin:fetch', start, end, 'ok', response);
+        }
+        catch (e) {
+            const end = datetime_1.NesoiDatetime.now();
+            const error = new error_1.NesoiError.BaseError('FetchError', e.toString(), 401, e);
+            return new trx_1.TrxStatus('#', 'plugin:fetch', start, end, 'error', undefined, error);
+        }
+    }
+    makeApiPath(endpoint) {
+        const domain = endpoint.path[0];
+        const root = domain.name
+            ? [this.schema.name, domain.version, domain.name]
+            : [this.schema.name, domain.version];
+        const list = [
+            ...root,
+            ...endpoint.path.slice(1).map(node => node.name),
+            endpoint.endpoint.schema.name.startsWith('#') ? '' : endpoint.endpoint.schema.name
+        ];
+        return '/' + list.join('/');
+    }
+}
+exports.FetchControllerAdapter = FetchControllerAdapter;

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

@@ -2,6 +2,7 @@ import type { $BlockAuth } from "../../blocks/block.schema";
 import type { $Message } from "../../entities/message/message.schema";
 import type { AnyUsers } from "../../../engine/auth/authn";
 import type { Tag } from "../../../engine/dependency";
+export type ControllerEndpointPath = ($ControllerDomain | $ControllerGroup | $ControllerEndpoint)[];
 /**
  * @category Schemas
  * @subcategory Edge
@@ -74,5 +75,13 @@ export declare class $Controller {
     $t: "controller";
     '#authn': AnyUsers;
     '#input': $Message;
+    '#path': Record<string, $Message>;
     constructor(module: string, name: string, alias: string, auth: $BlockAuth[], input: Tag[], domains?: Record<string, $ControllerDomain>, topics?: Record<string, $ControllerTopic>);
+    static endpoints(schema: $Controller): {
+        [path_str: string]: {
+            path: ControllerEndpointPath;
+            endpoint: $ControllerEndpoint;
+        };
+    };
+    static makePath(schema: $Controller, path: ControllerEndpointPath, endpoint: $ControllerEndpoint): string;
 }