nesoi 3.0.0

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

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceBuilder = void 0;
+const resource_schema_1 = require("./resource.schema");
+const resource_job_builder_1 = require("../job/internal/resource_job.builder");
+const block_builder_1 = require("../block.builder");
+const error_1 = require("../../../engine/data/error");
+const message_builder_1 = require("../../entities/message/message.builder");
+const bucket_model_convert_1 = require("../../entities/bucket/model/bucket_model.convert");
+const dependency_1 = require("../../../engine/dependency");
+const name_helpers_1 = require("../../../compiler/helpers/name_helpers");
+const job_builder_1 = require("../job/job.builder");
+const resource_1 = require("./resource");
+const resource_job_1 = require("../job/internal/resource_job");
+class ResourceBuilder extends block_builder_1.BlockBuilder {
+    constructor(module, name) {
+        super(module, 'resource', name);
+        this.$b = 'resource';
+        this._jobs = {};
+    }
+    /* [Block] */
+    authn(...providers) {
+        return super.authn(...providers);
+    }
+    /* Bucket */
+    bucket(name) {
+        this._bucket = new dependency_1.$Dependency(this.module, 'bucket', name);
+        return this;
+    }
+    /* Read */
+    view(...views) {
+        const name = `${this.name}.view`;
+        const alias = `View ${this._alias || this.name}`;
+        const jobBuilder = new resource_job_builder_1.ResourceJobBuilder(this.module, name, this._bucket.refName, 'view', alias, resource_1.Resource.view, this._authn)
+            .input($ => ({
+            view: $.enum(views).default(views[0]),
+            id: $.string_or_number.optional,
+            perPage: $.int.default(10),
+            page: $.int.default(0),
+            orderBy: $.string.optional,
+            orderDesc: $.boolean.default(false)
+        }))
+            .prepare(resource_job_1.ResourceJob.prepareMsgData);
+        this._inlineNodes.push(new dependency_1.BuilderNode({
+            module: this.module,
+            type: 'job',
+            name: name,
+            builder: jobBuilder,
+            isInline: true,
+            filepath: [], // This is added later by Treeshake.blockInlineNodes()
+            dependencies: [] // This is added later by Treeshake.*()
+        }));
+        this._jobs.view = new dependency_1.$Dependency(this.module, 'job', name);
+        return this;
+    }
+    query(...views) {
+        const name = `${this.name}.query`;
+        const alias = `Query ${this._alias || this.name}`;
+        const jobBuilder = new resource_job_builder_1.ResourceJobBuilder(this.module, name, this._bucket.refName, 'query', alias, resource_1.Resource.query, this._authn)
+            .input($ => ({
+            view: $.enum(views).default(views[0]),
+            query: $.dict($.any),
+            perPage: $.int.default(10),
+            page: $.int.default(0),
+            orderBy: $.string.optional,
+            orderDesc: $.boolean.default(false)
+        }))
+            .prepare(resource_job_1.ResourceJob.prepareMsgData);
+        this._inlineNodes.push(new dependency_1.BuilderNode({
+            module: this.module,
+            type: 'job',
+            name: name,
+            builder: jobBuilder,
+            isInline: true,
+            filepath: [], // This is added later by Treeshake.blockInlineNodes()
+            dependencies: [] // This is added later by Treeshake.*()
+        }));
+        this._jobs.query = new dependency_1.$Dependency(this.module, 'job', name);
+        return this;
+    }
+    /* Create/Update/Delete */
+    create($) {
+        const name = `${this.name}.create`;
+        const alias = `Create ${this._alias || this.name}`;
+        const jobBuilder = new resource_job_builder_1.ResourceJobBuilder(this.module, name, this._bucket.refName, 'create', alias, resource_1.Resource.create, this._authn)
+            .prepare(resource_job_1.ResourceJob.prepareMsgData);
+        $(jobBuilder);
+        this._inlineNodes.push(new dependency_1.BuilderNode({
+            module: this.module,
+            type: 'job',
+            name: name,
+            builder: jobBuilder,
+            isInline: true,
+            filepath: [], // This is added later by Treeshake.blockInlineNodes()
+            dependencies: [] // This is added later by Treeshake.*()
+        }));
+        this._jobs.create = new dependency_1.$Dependency(this.module, 'job', name);
+        return this;
+    }
+    update($) {
+        const name = `${this.name}.update`;
+        const alias = `Update ${this._alias || this.name}`;
+        const jobBuilder = new resource_job_builder_1.ResourceJobBuilder(this.module, name, this._bucket.refName, 'update', alias, resource_1.Resource.update, this._authn, {
+            id: ['string_or_number', undefined]
+        })
+            .prepare(resource_job_1.ResourceJob.prepareMsgData);
+        $(jobBuilder);
+        this._inlineNodes.push(new dependency_1.BuilderNode({
+            module: this.module,
+            type: 'job',
+            name: name,
+            builder: jobBuilder,
+            isInline: true,
+            filepath: [], // This is added later by Treeshake.blockInlineNodes()
+            dependencies: [] // This is added later by Treeshake.*()
+        }));
+        this._jobs.update = new dependency_1.$Dependency(this.module, 'job', name);
+        return this;
+    }
+    delete($) {
+        const name = `${this.name}.delete`;
+        const alias = `Delete ${this._alias || this.name}`;
+        const jobBuilder = new resource_job_builder_1.ResourceJobBuilder(this.module, name, this._bucket.refName, 'delete', alias, resource_1.Resource.delete, this._authn, {
+            id: ['string_or_number', undefined]
+        })
+            .prepare(resource_job_1.ResourceJob.prepareTrue);
+        $(jobBuilder);
+        this._inlineNodes.push(new dependency_1.BuilderNode({
+            module: this.module,
+            type: 'job',
+            name: name,
+            builder: jobBuilder,
+            isInline: true,
+            filepath: [], // This is added later by Treeshake.blockInlineNodes()
+            dependencies: [] // This is added later by Treeshake.*()
+        }));
+        this._jobs.delete = new dependency_1.$Dependency(this.module, 'job', name);
+        return this;
+    }
+    // Build
+    static build(node, tree, module) {
+        const bucket = tree.getSchema(node.builder._bucket);
+        if (!bucket) {
+            throw error_1.NesoiError.Builder.Resource.BucketNotFound(node.builder.name, node.builder._bucket.refName);
+        }
+        const model = bucket.model;
+        const modelName = name_helpers_1.NameHelpers.nameLowToHigh(bucket.name);
+        const inlineMsgs = {};
+        const inlineJobs = {};
+        const inlineJobsConfig = {};
+        // view
+        const viewDep = node.builder._jobs.view;
+        if (viewDep) {
+            inlineJobsConfig[viewDep.name] = {
+                ResourceJob: {
+                    output: { raw: modelName + ' | ' + modelName + '[]' },
+                    defaultTrigger: undefined
+                }
+            };
+        }
+        // query
+        const queryDep = node.builder._jobs.query;
+        if (queryDep) {
+            inlineJobsConfig[queryDep.name] = {
+                ResourceJob: {
+                    idType: null,
+                    output: { raw: modelName + '[]' },
+                    defaultTrigger: undefined
+                }
+            };
+        }
+        // create
+        const createDep = node.builder._jobs.create;
+        if (createDep) {
+            const defaultTrigger = (0, bucket_model_convert_1.convertToMessage)(module.name, model, createDep.name, `Create ${node.builder._alias || node.builder.name}`, [], ['id']);
+            inlineJobsConfig[createDep.name] = {
+                ResourceJob: {
+                    idType: null,
+                    output: { raw: modelName },
+                    defaultTrigger
+                }
+            };
+        }
+        // update
+        const updateDep = node.builder._jobs.update;
+        if (updateDep) {
+            const defaultTrigger = (0, bucket_model_convert_1.convertToMessage)(module.name, model, updateDep.name, `Update ${node.builder._alias || node.builder.name}`, [], []);
+            inlineJobsConfig[updateDep.name] = {
+                ResourceJob: {
+                    idType: model.fields.id.type,
+                    output: { raw: modelName },
+                    defaultTrigger
+                }
+            };
+        }
+        // delete
+        const deleteDep = node.builder._jobs.delete;
+        if (deleteDep) {
+            const defaultTrigger = (0, bucket_model_convert_1.convertToMessage)(module.name, model, deleteDep.name, `Delete ${node.builder._alias || node.builder.name}`, ['id'], []);
+            inlineJobsConfig[deleteDep.name] = {
+                ResourceJob: {
+                    idType: model.fields.id.type,
+                    output: { raw: 'void' },
+                    defaultTrigger
+                }
+            };
+        }
+        node.schema = new resource_schema_1.$Resource(node.builder.module, node.builder.name, node.builder._alias || node.builder.name, node.builder._authn, node.builder._bucket, node.builder._jobs);
+        const jobs = job_builder_1.JobBuilder.buildInlines(node, tree, module, inlineJobsConfig);
+        return {
+            schema: node.schema,
+            inlineMessages: {
+                ...message_builder_1.MessageBuilder.buildInlines(node, tree, module),
+                ...jobs.nestedInlineMessages,
+                ...inlineMsgs,
+            },
+            inlineJobs: {
+                ...jobs.inlineJobs,
+                ...inlineJobs
+            }
+        };
+    }
+}
+exports.ResourceBuilder = ResourceBuilder;

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

@@ -0,0 +1,48 @@
+import { $Module, $Space } from "../../../schema";
+import { $Resource } from './resource.schema';
+import { Block } from "../block";
+import { NesoiObj } from "../../../engine/data/obj";
+import { AnyMessage } from "../../entities/message/message";
+import { Module } from "../../../engine/module";
+import { AnyTrxNode, TrxNode } from "../../../engine/transaction/trx_node";
+import { $Dependency } from "../../../engine/dependency";
+import { ResourceAssertions } from '../job/internal/resource_job.builder';
+import { $Job } from '../job/job.schema';
+export declare class Resource<S extends $Space, M extends $Module, $ extends $Resource> extends Block<S, M, $> {
+    module: Module<S, M>;
+    schema: $;
+    constructor(module: Module<S, M>, schema: $);
+    protected run(trx: TrxNode<S, M, $['#authn']>, msg: AnyMessage): Promise<unknown>;
+    private view;
+    private query;
+    private create;
+    private update;
+    private delete;
+    static view($: {
+        trx: AnyTrxNode;
+        msg: any;
+        job: $Job;
+    }): Promise<any>;
+    static query($: {
+        trx: AnyTrxNode;
+        msg: any;
+        job: $Job;
+    }): Promise<any[]>;
+    static create($: {
+        trx: AnyTrxNode;
+        obj: any;
+        job: $Job;
+    }): Promise<any>;
+    static update($: {
+        trx: AnyTrxNode;
+        obj: any;
+        job: $Job;
+    }): Promise<any>;
+    static delete($: {
+        trx: AnyTrxNode;
+        obj: any;
+        job: $Job;
+    }): Promise<void> | undefined;
+    static assertThat(trx: AnyTrxNode, bucket: $Dependency, obj: NesoiObj | undefined, type: keyof ResourceAssertions<any>, arg: any): Promise<boolean | undefined>;
+}
+export type AnyResource = Resource<any, any, any>;

package/lib/elements/blocks/resource/resource.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Resource = void 0;
+const block_1 = require("../block");
+const trx_node_1 = require("../../../engine/transaction/trx_node");
+const error_1 = require("../../../engine/data/error");
+class Resource extends block_1.Block {
+    constructor(module, schema) {
+        super('resource', module, schema);
+        this.module = module;
+        this.schema = schema;
+    }
+    async run(trx, msg) {
+        if (msg.$.endsWith('.view')) {
+            return this.view(trx, msg);
+        }
+        if (msg.$.endsWith('.query')) {
+            return this.query(trx, msg);
+        }
+        if (msg.$.endsWith('.create')) {
+            return this.create(trx, msg);
+        }
+        if (msg.$.endsWith('.update')) {
+            return this.update(trx, msg);
+        }
+        if (msg.$.endsWith('.delete')) {
+            return this.delete(trx, msg);
+        }
+    }
+    async view(trx, msg) {
+        if (!this.schema.jobs.view) {
+            throw error_1.NesoiError.Resource.ViewNotSupported(this.schema);
+        }
+        return trx.job(this.schema.jobs.view.refName).forward(msg);
+    }
+    async query(trx, msg) {
+        // const q = $BucketQuery.parse(msg.query);
+        // const node = trx.bucket(this.schema.bucket.refName).query(msg.view, q);
+        // if (msg.orderBy) {
+        //     node.orderBy(msg.orderBy as keyof NesoiObj, msg.orderDesc ? 'desc' : 'asc');
+        // }
+        // return node.page({
+        //     perPage: msg.perPage,
+        //     page: msg.page
+        // });
+        if (!this.schema.jobs.query) {
+            throw error_1.NesoiError.Resource.QueryNotSupported(this.schema);
+        }
+        return trx.job(this.schema.jobs.query.refName).forward(msg);
+    }
+    async create(trx, msg) {
+        if (!this.schema.jobs.create) {
+            throw error_1.NesoiError.Resource.CreateNotSupported(this.schema);
+        }
+        return trx_node_1.TrxNode.jobWithCustomCtx(trx, this.schema.jobs.create.refName, {
+            that: (type, arg) => Resource.assertThat(trx, this.schema.bucket, undefined, type, arg)
+        }).forward(msg);
+    }
+    async update(trx, msg) {
+        if (!this.schema.jobs.update) {
+            throw error_1.NesoiError.Resource.UpdateNotSupported(this.schema);
+        }
+        const obj = await trx.bucket(this.schema.bucket.refName).readOneOrFail(msg.id);
+        return trx_node_1.TrxNode.jobWithCustomCtx(trx, this.schema.jobs.update.refName, {
+            that: (type, arg) => Resource.assertThat(trx, this.schema.bucket, obj, type, arg),
+            obj,
+        })
+            .forward(msg);
+    }
+    async delete(trx, msg) {
+        if (!this.schema.jobs.delete) {
+            throw error_1.NesoiError.Resource.DeleteNotSupported(this.schema);
+        }
+        const obj = await trx.bucket(this.schema.bucket.refName).readOneOrFail(msg.id);
+        return trx_node_1.TrxNode.jobWithCustomCtx(trx, this.schema.jobs.delete.refName, {
+            that: (type, arg) => Resource.assertThat(trx, this.schema.bucket, obj, type, arg),
+            obj,
+        })
+            .forward(msg);
+    }
+    static view($) {
+        const scope = $.job.scope;
+        return $.msg.id
+            ? $.trx.bucket(scope.bucket).viewOneOrFail($.msg.id, $.msg.view)
+            : $.trx.bucket(scope.bucket).viewAll($.msg.view);
+    }
+    static query($) {
+        const scope = $.job.scope;
+        return $.trx.bucket(scope.bucket)
+            .query($.msg.query).all();
+    }
+    static create($) {
+        const scope = $.job.scope;
+        return $.trx.bucket(scope.bucket)
+            .create($.obj);
+    }
+    static update($) {
+        const scope = $.job.scope;
+        return $.trx.bucket(scope.bucket)
+            .patch($.obj);
+    }
+    static delete($) {
+        const scope = $.job.scope;
+        if (!$.obj) {
+            return;
+        }
+        return $.trx.bucket(scope.bucket)
+            .deleteOrFail($.obj.id);
+    }
+    // Custom assertions
+    static async assertThat(trx, bucket, obj, type, arg) {
+        if (type === 'query is empty') {
+            return !(await trx.bucket(bucket.refName)
+                .query(arg)
+                .first());
+        }
+        if (type === 'has no link') {
+            if (!obj)
+                return true;
+            return !(await trx.bucket(bucket.refName)
+                .hasLink(obj.id, arg));
+        }
+    }
+}
+exports.Resource = Resource;

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

@@ -0,0 +1,32 @@
+import { $Block } from "../block.schema";
+import { $Bucket } from "../../entities/bucket/bucket.schema";
+import { $Message } from "../../entities/message/message.schema";
+import { $Dependency } from "../../../engine/dependency";
+export declare class $Resource extends $Block {
+    module: string;
+    name: string;
+    alias: string;
+    authn: string[];
+    bucket: $Dependency;
+    jobs: {
+        view?: $Dependency;
+        query?: $Dependency;
+        create?: $Dependency;
+        update?: $Dependency;
+        delete?: $Dependency;
+    };
+    $t: "resource";
+    '#bucket': $Bucket;
+    '#input.view': $Message;
+    '#input.query': $Message;
+    '#input.create': $Message;
+    '#input.update': $Message;
+    '#input.delete': $Message;
+    constructor(module: string, name: string, alias: string, authn: string[], bucket: $Dependency, jobs: {
+        view?: $Dependency;
+        query?: $Dependency;
+        create?: $Dependency;
+        update?: $Dependency;
+        delete?: $Dependency;
+    });
+}

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$Resource = void 0;
+const block_schema_1 = require("../block.schema");
+const dependency_1 = require("../../../engine/dependency");
+class $Resource extends block_schema_1.$Block {
+    constructor(module, name, alias, authn, bucket, jobs) {
+        const input = [];
+        if (jobs.view)
+            input.push(new dependency_1.$Dependency(module, 'message', jobs.view.name));
+        if (jobs.query)
+            input.push(new dependency_1.$Dependency(module, 'message', jobs.query.name));
+        if (jobs.create)
+            input.push(new dependency_1.$Dependency(module, 'message', jobs.create.name));
+        if (jobs.update)
+            input.push(new dependency_1.$Dependency(module, 'message', jobs.update.name));
+        if (jobs.delete)
+            input.push(new dependency_1.$Dependency(module, 'message', jobs.delete.name));
+        // TODO: Input dependencies
+        super(module, name, alias, authn, input, {});
+        this.module = module;
+        this.name = name;
+        this.alias = alias;
+        this.authn = authn;
+        this.bucket = bucket;
+        this.jobs = jobs;
+        this.$t = 'resource';
+    }
+}
+exports.$Resource = $Resource;

package/lib/elements/blocks/resource/resource.types.d.ts

@@ -0,0 +1,38 @@
+import { $Module, $Space } from "../../../schema";
+import { $Resource } from './resource.schema';
+import { NesoiObjId, UndefinedToOptional } from "../../../engine/data/obj";
+import { ResourceJobDef } from '../job/internal/resource_job.builder';
+import { $Message } from "../../entities/message/message.schema";
+import { Overlay } from "../../../engine/util/type";
+export type asResourceCreateJob<S extends $Space, Module extends keyof S['modules'], Res extends keyof S['modules'][Module]['resources'], M extends $Module = S['modules'][Module], $ extends $Resource = M['resources'][Res], Response extends Record<string, any> = UndefinedToOptional<Omit<$['#bucket']['#data'], 'id'>>, MsgName extends string = `${$['name']}.create`, MsgData extends Record<string, any> = Omit<$['#bucket']['#data'], 'id'>, DefaultTrigger extends $Message = Overlay<$Message, {
+    $: MsgName;
+    '#raw': MsgData['#input'] & {
+        $: MsgData['$'];
+    };
+    '#parsed': MsgData['#output'] & {
+        $: MsgData['$'];
+    };
+    fields: any;
+}>> = ResourceJobDef<S, M, MsgName, Response, $['#authn'], $['#bucket'], DefaultTrigger>;
+export type asResourceUpdateJob<S extends $Space, Module extends keyof S['modules'], Res extends keyof S['modules'][Module]['resources'], M extends $Module = S['modules'][Module], $ extends $Resource = M['resources'][Res], Response extends Record<string, any> = UndefinedToOptional<Omit<$['#bucket']['#data'], 'id'>>, MsgName extends string = `${$['name']}.update`, MsgData extends Record<string, any> = $['#bucket']['#data'], DefaultTrigger extends $Message = Overlay<$Message, {
+    $: MsgName;
+    '#raw': MsgData['#input'] & {
+        $: MsgData['$'];
+    };
+    '#parsed': MsgData['#output'] & {
+        $: MsgData['$'];
+    };
+    fields: any;
+}>> = ResourceJobDef<S, M, MsgName, Response, $['#authn'], $['#bucket'], DefaultTrigger>;
+export type asResourceDeleteJob<S extends $Space, Module extends keyof S['modules'], Res extends keyof S['modules'][Module]['resources'], M extends $Module = S['modules'][Module], $ extends $Resource = M['resources'][Res], MsgName extends string = `${$['name']}.update`, MsgData extends Record<string, any> = $['#bucket']['#data'], DefaultTrigger extends $Message = Overlay<$Message, {
+    $: MsgName;
+    '#raw': MsgData['#input'] & {
+        $: MsgData['$'];
+    };
+    '#parsed': MsgData['#output'] & {
+        $: MsgData['$'];
+    };
+    fields: any;
+}>> = ResourceJobDef<S, M, MsgName, boolean, $['#authn'], $['#bucket'], DefaultTrigger, {
+    id: NesoiObjId;
+}>;

package/lib/elements/blocks/resource/resource.types.js

@@ -0,0 +1,3 @@
+"use strict";
+/* File splitters */
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIControllerAdapter = void 0;
+const controller_adapter_1 = require("./controller_adapter");
+const controller_1 = require("../controller");
+const log_1 = require("../../../../engine/util/log");
+class CLIControllerAdapter extends controller_adapter_1.ControllerAdapter {
+    constructor() {
+        super(...arguments);
+        this.endpoints = {};
+    }
+    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}'`);
+    }
+}
+exports.CLIControllerAdapter = CLIControllerAdapter;

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

@@ -0,0 +1,14 @@
+import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
+import { $Controller, $ControllerDomain, $ControllerEndpoint, $ControllerGroup } from '../controller.schema';
+import { AnyDaemon } from "../../../../engine/daemon";
+export type ControllerEndpointPath = ($ControllerDomain | $ControllerGroup | $ControllerEndpoint)[];
+export declare abstract class ControllerAdapter {
+    protected schema: $Controller;
+    protected daemon?: AnyDaemon;
+    constructor(schema: $Controller);
+    trx(fn: (trx: AnyTrxNode) => Promise<any>): Promise<import("../../../../engine/transaction/trx").TrxStatus<any>>;
+    bind(daemon: AnyDaemon): void;
+    protected abstract makeEndpoint(path: string, schema: $ControllerEndpoint): void;
+    protected makeGroup(group: $ControllerGroup, root?: ControllerEndpointPath): void;
+    protected makePath(schema: $Controller, path: ControllerEndpointPath): string;
+}

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ControllerAdapter = void 0;
+class ControllerAdapter {
+    constructor(schema) {
+        this.schema = schema;
+    }
+    trx(fn) {
+        if (!this.daemon) {
+            throw new Error('Controller not bound to a daemon');
+        }
+        return this.daemon.trx(this.schema.module).run(fn);
+    }
+    bind(daemon) {
+        this.daemon = daemon;
+        for (const d in this.schema.domains) {
+            const domain = this.schema.domains[d];
+            this.makeGroup(domain, [domain]);
+        }
+    }
+    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);
+        }
+    }
+    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('/');
+    }
+}
+exports.ControllerAdapter = ControllerAdapter;

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

@@ -0,0 +1,78 @@
+import { $Module, $Space } from "../../../schema";
+import { $Controller, $ControllerDomain, $ControllerEndpoint, $ControllerGroup } from './controller.schema';
+import { $Message } from "../../entities/message/message.schema";
+import { $Dependency, ResolvedBuilderNode } from "../../../engine/dependency";
+type JobsSupportingMsg<M extends $Module, Msg extends $Message> = {
+    [J in keyof M['jobs']]: Msg extends M['jobs'][J]['#input'] ? J : never;
+}[keyof M['jobs']];
+type ResourcesSupportingMsg<M extends $Module, Msg extends $Message> = {
+    [J in keyof M['resources']]: Msg extends M['resources'][J]['#input'] ? J : never;
+}[keyof M['resources']];
+type MachinesSupportingMsg<M extends $Module, Msg extends $Message> = {
+    [J in keyof M['machines']]: Msg extends M['machines'][J]['#input'] ? J : never;
+}[keyof M['machines']];
+export declare class ControllerEndpointBuilder<S extends $Space, M extends $Module, Msg extends $Message = never> {
+    private module;
+    private name;
+    private _alias?;
+    private _version?;
+    private _authn;
+    private _tags;
+    private _msg;
+    private _target;
+    constructor(module: string, name: string);
+    as(alias: string): this;
+    authn<U extends keyof S['authnUsers']>(providers: U | U[]): this;
+    tag(tag: string): this;
+    tags(tags: string[]): this;
+    msg<K extends keyof M['messages']>(msg: K): ControllerEndpointBuilder<S, M, M["messages"][K]>;
+    toJob(job: JobsSupportingMsg<M, Msg>): this;
+    toResource(resource: ResourcesSupportingMsg<M, Msg>): this;
+    toMachine(machine: MachinesSupportingMsg<M, Msg>): this;
+    static build(builder: ControllerEndpointBuilder<any, any>): $ControllerEndpoint;
+}
+export declare class ControllerGroupBuilder<S extends $Space, M extends $Module> {
+    private module;
+    protected name: string;
+    protected _alias?: string;
+    protected _authn: string[];
+    protected groups: Record<string, ControllerGroupBuilder<any, any>>;
+    protected endpoints: Record<string, ControllerEndpointBuilder<any, any>>;
+    constructor(module: string, name: string);
+    as(alias: string): this;
+    authn<U extends keyof S['authnUsers']>(providers: U | U[]): this;
+    endpoint(name: string, $: ControllerEndpointDef<S, M>): this;
+    group(name: string, $: ControllerGroupDef<S, M>): this;
+    static build(builder: ControllerGroupBuilder<any, any>): $ControllerGroup;
+    static buildGroups(builders: Record<string, ControllerGroupBuilder<any, any>>): Record<string, $ControllerGroup>;
+    static buildEndpoints(builders: Record<string, ControllerEndpointBuilder<any, any>>): Record<string, $ControllerEndpoint>;
+}
+export declare class ControllerDomainBuilder<S extends $Space, M extends $Module> extends ControllerGroupBuilder<S, M> {
+    private _version;
+    version(version: string): this;
+    static build(builder: ControllerDomainBuilder<any, any>): $ControllerDomain;
+}
+export declare class ControllerBuilder<S extends $Space, M extends $Module> {
+    private module;
+    private name;
+    $b: "controller";
+    private _alias?;
+    private _authn;
+    private domains;
+    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;
+    static build(node: ControllerBuilderNode): $Controller;
+    static buildInput(group: $ControllerGroup): $Dependency[];
+    static buildDomains(builders: Record<string, ControllerDomainBuilder<any, any>>): Record<string, $ControllerDomain>;
+}
+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 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'> & {
+    builder: AnyControllerBuilder;
+    schema?: $Controller;
+};
+export {};