nesoi 3.0.0

package/lib/elements/blocks/job/internal/resource_job.builder.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceJobBuilder = void 0;
+const job_schema_1 = require("../job.schema");
+const message_template_field_builder_1 = require("../../../entities/message/template/message_template_field.builder");
+const block_builder_1 = require("../../block.builder");
+const message_builder_1 = require("../../../entities/message/message.builder");
+const dependency_1 = require("../../../../engine/dependency");
+const error_1 = require("../../../../engine/data/error");
+const resource_job_1 = require("./resource_job");
+class ResourceJobBuilder extends block_builder_1.BlockBuilder {
+    constructor(module, name, bucket, method, alias, execMethod, _authn = [], implicitFields = {}) {
+        super(module, 'job', name);
+        this.module = module;
+        this.name = name;
+        this.bucket = bucket;
+        this.method = method;
+        this.alias = alias;
+        this.execMethod = execMethod;
+        this._authn = _authn;
+        this.implicitFields = implicitFields;
+        this.$b = 'job';
+        this.$j = 'ResourceJob';
+        this._customInput = false;
+        this._extrasAndAsserts = [];
+        this.resource = this.name.split('.')[0];
+        this._msg = new message_builder_1.MessageBuilder(module, name)
+            .as(alias);
+        super._input(name);
+        this._inlineNodes.push(new dependency_1.BuilderNode({
+            module: this.module,
+            type: 'message',
+            name: name,
+            builder: this._msg,
+            isInline: true,
+            filepath: [], // This is added later by Treeshake.blockInlineNodes()
+            dependencies: [] // This is added later by Treeshake.*()
+        }));
+    }
+    /**
+     * The input message accepted by the job.
+     *
+     * @param def A `$ => ({})` definition for a custom trigger message
+     */
+    input(def) {
+        this._msg.template($ => {
+            const fields = def($);
+            for (const f in this.implicitFields || []) {
+                const [type, arg] = this.implicitFields[f];
+                fields[f] = arg
+                    ? $[type](arg)
+                    : $[type];
+            }
+            return fields;
+        });
+        this._customInput = true;
+        this._prepareMethod = undefined;
+        this._afterMethod = undefined;
+        return this;
+    }
+    /*
+        With
+    */
+    /**
+     * A function that will build new fields on the input message to be
+     * consumed by the job.
+     *
+     * @param $ A function which returns an object to be assigned to the input.
+     */
+    extra($) {
+        this._extrasAndAsserts.push({ extra: $ });
+        return this;
+    }
+    /*
+        Assert
+    */
+    /**
+     * A function that checks a given condition over the input and throws an exception;
+     * This assertion runs before the job method.
+     *
+     * @param { cond } A function which returns true or false
+     * @param { error } An error message or a function that makes one
+     */
+    assert(condition) {
+        this._extrasAndAsserts.push({ assert: condition });
+        return this;
+    }
+    /*
+        Action
+    */
+    /**
+     * The function called to prepare the input for the job.
+     *
+     * @param method A function which returns the required output.
+     */
+    prepare(method) {
+        this._prepareMethod = method;
+        return this;
+    }
+    /**
+     * The function called after the input has been processed.
+     *
+     * @param method A function which returns void.
+     */
+    after(method) {
+        this._afterMethod = method;
+        return this;
+    }
+    // Build
+    static build(node, tree, module, output, defaultTrigger, idType) {
+        if (node.builder._customInput && !node.builder._prepareMethod) {
+            throw error_1.NesoiError.Builder.Resource.CustomInputRequiresPrepare(node.builder.name);
+        }
+        const fields = node.builder._msg._template._fields;
+        if (idType !== undefined) {
+            if (idType) {
+                fields['id'] = new message_template_field_builder_1.MessageTemplateFieldBuilder(idType, {});
+            }
+            else {
+                delete fields['id'];
+            }
+        }
+        node.schema = new job_schema_1.$Job(node.builder.module, node.builder.name, node.builder.alias || node.builder.name, node.builder._authn, [new dependency_1.$Dependency(node.module, 'message', node.builder.name)], output, node.builder._extrasAndAsserts, resource_job_1.ResourceJob.method, {
+            module: node.builder.module,
+            resource: node.builder.resource,
+            bucket: node.builder.bucket,
+            method: node.builder.method,
+            prepareMethod: node.builder._prepareMethod,
+            execMethod: node.builder.execMethod,
+            afterMethod: node.builder._afterMethod
+        });
+        let inlineMessages;
+        if (node.builder._customInput) {
+            inlineMessages = message_builder_1.MessageBuilder.buildInlines(node, tree, module);
+        }
+        else {
+            inlineMessages = { [defaultTrigger.name]: defaultTrigger };
+            node.inlines.message[node.builder.name].schema = defaultTrigger;
+        }
+        return {
+            schema: node.schema,
+            inlineMessages
+        };
+    }
+}
+exports.ResourceJobBuilder = ResourceJobBuilder;

package/lib/elements/blocks/job/internal/resource_job.d.ts

@@ -0,0 +1,14 @@
+import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
+import { $Job } from '../job.schema';
+import { AnyMessage } from "../../../entities/message/message";
+export declare class ResourceJob {
+    static method($: {
+        trx: AnyTrxNode;
+        msg: any;
+        job: $Job;
+    }): Promise<any>;
+    static prepareMsgData($: {
+        msg: any;
+    }): Promise<Omit<AnyMessage, "$" | "__meta__" | "getData">>;
+    static prepareTrue(): Promise<boolean>;
+}

package/lib/elements/blocks/job/internal/resource_job.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceJob = void 0;
+class ResourceJob {
+    static async method($) {
+        const scope = $.job.scope;
+        let obj;
+        if (scope.method === 'update' || scope.method === 'delete') {
+            obj = await $.trx.bucket(scope.bucket).readOneOrFail($.msg.id);
+        }
+        obj = await scope.prepareMethod({ ...$, obj, bucket: scope.bucket });
+        if (scope.execMethod) {
+            obj = await scope.execMethod({ ...$, obj, bucket: scope.bucket });
+        }
+        if (scope.afterMethod) {
+            obj = await scope.afterMethod({ ...$, obj, bucket: scope.bucket });
+        }
+        return obj;
+    }
+    // The methods below exist so the JobElement is able
+    // to identify these methods and replace them with the
+    // proper text on the built element.
+    static async prepareMsgData($) {
+        return $.msg.getData();
+    }
+    static async prepareTrue() {
+        return true;
+    }
+}
+exports.ResourceJob = ResourceJob;

package/lib/elements/blocks/job/internal/resource_job.schema.d.ts

@@ -0,0 +1,11 @@
+import { $JobMethod } from '../job.schema';
+export declare class $ResourceJobScope {
+    module: string;
+    resource: string;
+    bucket: string;
+    method: 'view' | 'query' | 'create' | 'update' | 'delete';
+    prepareMethod: $JobMethod<any, any, any, any>;
+    execMethod?: $JobMethod<any, any, any, any> | undefined;
+    afterMethod?: $JobMethod<any, any, any, any> | undefined;
+    constructor(module: string, resource: string, bucket: string, method: 'view' | 'query' | 'create' | 'update' | 'delete', prepareMethod: $JobMethod<any, any, any, any>, execMethod?: $JobMethod<any, any, any, any> | undefined, afterMethod?: $JobMethod<any, any, any, any> | undefined);
+}

package/lib/elements/blocks/job/internal/resource_job.schema.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$ResourceJobScope = void 0;
+class $ResourceJobScope {
+    constructor(module, resource, bucket, method, prepareMethod, execMethod, afterMethod) {
+        this.module = module;
+        this.resource = resource;
+        this.bucket = bucket;
+        this.method = method;
+        this.prepareMethod = prepareMethod;
+        this.execMethod = execMethod;
+        this.afterMethod = afterMethod;
+    }
+}
+exports.$ResourceJobScope = $ResourceJobScope;

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

@@ -0,0 +1,118 @@
+import { $Module, $Space, ScopedMessage, ScopedMessageName } from "../../../schema";
+import { $Job, $JobAssert, $JobMethod } from './job.schema';
+import { BlockBuilder } from '../block.builder';
+import { MultiMessageTemplateDef } from "../../entities/message/template/message_template.builder";
+import { Overlay } from "../../../engine/util/type";
+import { $MessageInfer } from "../../entities/message/message.infer";
+import { TrxNode } from "../../../engine/transaction/trx_node";
+import { ModuleTree } from "../../../engine/tree";
+import { $Dependency, ResolvedBuilderNode } from "../../../engine/dependency";
+import { $Message } from "../../entities/message/message.schema";
+import { $BlockOutput } from '../block.schema';
+export type JobExtrasAndAsserts = ({
+    extra: $JobMethod<any, any, any, any, any>;
+} | {
+    assert: $JobAssert<any, any, any, any>;
+})[];
+export declare class JobBuilder<Space extends $Space, Module extends $Module, Job extends $Job = $Job, Ctx = {}> extends BlockBuilder<Space, Module, 'job'> {
+    $b: "job";
+    $j: "Job";
+    private _extrasAndAsserts;
+    private _method?;
+    private _scope?;
+    constructor(module: string, name: Job['name']);
+    authn<U extends keyof Space['authnUsers']>(...providers: U[]): JobBuilder<Space, Module, Overlay<Job, {
+        "#authn": { [K in U]: Space["authnUsers"][U]; };
+    }>, Ctx>;
+    scope<JobScope extends `machine:${keyof Module['machines'] & string}`, Machine extends NoInfer<Module['machines'][JobScope extends `machine:${infer X}` ? X : never]>>(scope: JobScope): JobBuilder<Space, Module, Job, {
+        obj: Machine["#data"];
+        from: keyof Machine["states"] & string;
+        to: keyof Machine["states"] & string;
+    }>;
+    messages<Def extends MultiMessageTemplateDef<Space, Module>>(def: Def): JobBuilder<Space, Overlay<Module, {
+        messages: Overlay<Module["messages"], { [K in keyof ReturnType<Def> as `${Job["name"]}${K extends "" ? "" : "."}${K & string}`]: $MessageInfer<`${Job["name"]}${K extends "" ? "" : "."}${K & string}`, ($: any) => ReturnType<Def>[K], ReturnType<Def>[K], import("../../entities/message/message.infer").$MessageInputInfer<ReturnType<Def>[K], ReturnType<Def>[K] extends infer T ? { [K_1 in keyof T]: ReturnType<Def>[K][K_1] extends import("../../entities/message/template/message_template_field.builder").MessageTemplateFieldBuilder<any, any, infer I, any, any, infer Opt extends [undefined, undefined], infer Nul extends [null, null]> ? {
+            path: `${K_1 & string}${keyof I & string}`;
+            data: I[keyof I];
+            opt: Opt[0];
+            nul: Nul[0];
+        } : never; } : never>, import("../../entities/message/message.infer").$MessageOutputInfer<ReturnType<Def>[K], ReturnType<Def>[K] extends infer T_1 ? { [K_2 in keyof T_1]: ReturnType<Def>[K][K_2] extends import("../../entities/message/template/message_template_field.builder").MessageTemplateFieldBuilder<any, any, any, infer O, any, infer Opt_1 extends [undefined, undefined], infer Nul_1 extends [null, null]> ? {
+            path: `${K_2 & string}${keyof O & string}`;
+            data: O[keyof O];
+            opt: Opt_1[1];
+            nul: Nul_1[1];
+        } : never; } : never>>; }>;
+    }>, Job, Ctx>;
+    input<MsgName extends ScopedMessageName<Module, Job['name']>, Msg extends NoInfer<ScopedMessage<Module, Job['name'], MsgName>>>(...def: MsgName[]): JobBuilder<Space, Module, Overlay<Job, {
+        "#input": Msg;
+    }>, Ctx>;
+    get output(): {
+        raw: <T>() => JobBuilder<Space, Module, Overlay<Job, {
+            "#output": unknown extends Job["#output"] ? T : (Job["#output"] | T);
+        }>, Ctx>;
+        msg: <MsgName extends ScopedMessageName<Module, Job["name"]>, Msg extends NoInfer<ScopedMessage<Module, Job["name"], MsgName>>>(...msgs: MsgName[]) => JobBuilder<Space, Module, Overlay<Job, {
+            "#output": unknown extends Job["#output"] ? Msg["#parsed"] : (Job["#output"] | Msg["#parsed"]);
+        }>, Ctx>;
+        obj: <BucketName extends keyof Module["buckets"], Bucket extends NoInfer<Module["buckets"][BucketName]>>(...objs: BucketName[]) => JobBuilder<Space, Module, Overlay<Job, {
+            "#output": unknown extends Job["#output"] ? Bucket["#data"] : (Job["#output"] | Bucket["#data"]);
+        }>, Ctx>;
+    };
+    protected outputRaw<T>(): JobBuilder<Space, Module, Overlay<Job, {
+        "#output": unknown extends Job["#output"] ? T : (Job["#output"] | T);
+    }>, Ctx>;
+    protected outputMsg<MsgName extends ScopedMessageName<Module, Job['name']>, Msg extends NoInfer<ScopedMessage<Module, Job['name'], MsgName>>>(...msgs: MsgName[]): JobBuilder<Space, Module, Overlay<Job, {
+        "#output": unknown extends Job["#output"] ? Msg["#parsed"] : (Job["#output"] | Msg["#parsed"]);
+    }>, Ctx>;
+    protected outputObj<BucketName extends keyof Module['buckets'], Bucket extends NoInfer<Module['buckets'][BucketName]>>(...objs: BucketName[]): JobBuilder<Space, Module, Overlay<Job, {
+        "#output": unknown extends Job["#output"] ? Bucket["#data"] : (Job["#output"] | Bucket["#data"]);
+    }>, Ctx>;
+    /**
+     * A function that will build new fields on the input message to be
+     * consumed by the job.
+     *
+     * @param $ A function which returns an object to be assigned to the input.
+     */
+    extra<Extra extends {
+        [_: string]: any;
+    }, Trx = NoInfer<TrxNode<Space, Module, Job['#authn']>>, Msg = NoInfer<Job['#input']['#parsed']>, PreviousExtras = NoInfer<Job['#extra']>, C = NoInfer<Ctx>>($: $JobMethod<Trx, Msg, Extra, PreviousExtras, C>): JobBuilder<Space, Module, Job & {
+        "#extra": Job["#extra"] & Extra;
+    }, Ctx>;
+    /**
+     * A function that checks a given condition over the input and throws an exception;
+     * This assertion runs before the job method.
+     *
+     * @param { cond } A function which returns true or false
+     * @param { error } An error message or a function that makes one
+     */
+    assert<Trx = NoInfer<TrxNode<Space, Module, Job['#authn']>>, Msg = NoInfer<Job['#input']['#parsed']>, Extras = NoInfer<Job['#extra']>, C = NoInfer<Ctx>>(condition: $JobAssert<Trx, Msg, Extras, C>): this;
+    /**
+     * The function called when the job is run.
+     *
+     * @param method A function which returns one of the output messages or the response message
+     */
+    method<Trx = NoInfer<TrxNode<Space, Module, Job['#authn']>>, Msg = NoInfer<Job['#input']['#parsed']>, Extras = NoInfer<Job['#extra']>, C = NoInfer<Ctx>>(method: $JobMethod<Trx, Msg, Job['#output'], Extras, C>): this;
+    static build(node: JobBuilderNode, tree: ModuleTree, module: $Module): {
+        schema: $Job;
+        inlineMessages: Record<string, $Message>;
+    };
+    static buildInlines(node: ResolvedBuilderNode, tree: ModuleTree, module: $Module, config?: JobBuildConfig): {
+        inlineJobs: Record<string, $Job>;
+        nestedInlineMessages: Record<string, $Message>;
+    };
+}
+export type AnyJobBuilder = JobBuilder<any, any, any>;
+export type JobBuilderNode = Omit<ResolvedBuilderNode, 'builder'> & {
+    builder: AnyJobBuilder;
+    schema?: $Job;
+};
+export type JobBuildConfig = {
+    [name: string]: {
+        ResourceJob?: {
+            idType?: 'string' | 'int' | null;
+            output: $BlockOutput;
+            defaultTrigger: $Message;
+        };
+        MachineJob?: {
+            input: $Dependency[];
+        };
+    };
+};

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

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobBuilder = void 0;
+const job_schema_1 = require("./job.schema");
+const block_builder_1 = require("../block.builder");
+const dependency_1 = require("../../../engine/dependency");
+const message_builder_1 = require("../../entities/message/message.builder");
+const resource_job_builder_1 = require("./internal/resource_job.builder");
+const machine_job_builder_1 = require("./internal/machine_job.builder");
+const error_1 = require("../../../engine/data/error");
+class JobBuilder extends block_builder_1.BlockBuilder {
+    constructor(module, name) {
+        super(module, 'job', name);
+        this.$b = 'job';
+        this.$j = 'Job';
+        this._extrasAndAsserts = [];
+    }
+    /* [Block] */
+    authn(...providers) {
+        return super.authn(...providers);
+    }
+    /* [Scope] */
+    scope(scope) {
+        this._scope = scope;
+        // Machine-scoped job
+        return this;
+    }
+    /* [Job] */
+    messages(def) {
+        return super.messages(def);
+    }
+    input(...def) {
+        return super._input(...def);
+    }
+    get output() {
+        return {
+            raw: this.outputRaw.bind(this),
+            msg: this.outputMsg.bind(this),
+            obj: this.outputObj.bind(this)
+        };
+    }
+    outputRaw() {
+        // super.outputRaw()
+        return this;
+    }
+    outputMsg(...msgs) {
+        super.outputMsg();
+        return this;
+    }
+    outputObj(...objs) {
+        super.outputObj();
+        return this;
+    }
+    /*
+        Extra
+    */
+    /**
+     * A function that will build new fields on the input message to be
+     * consumed by the job.
+     *
+     * @param $ A function which returns an object to be assigned to the input.
+     */
+    extra($) {
+        this._extrasAndAsserts.push({ extra: $ });
+        return this;
+    }
+    /*
+        Assert
+    */
+    /**
+     * A function that checks a given condition over the input and throws an exception;
+     * This assertion runs before the job method.
+     *
+     * @param { cond } A function which returns true or false
+     * @param { error } An error message or a function that makes one
+     */
+    assert(condition) {
+        this._extrasAndAsserts.push({ assert: condition });
+        return this;
+    }
+    /*
+        Action
+    */
+    /**
+     * The function called when the job is run.
+     *
+     * @param method A function which returns one of the output messages or the response message
+     */
+    method(method) {
+        this._method = method;
+        return this;
+    }
+    // Build
+    static build(node, tree, module) {
+        if (!node.builder._method) {
+            throw error_1.NesoiError.Builder.Job.NoMethod({ job: node.builder.name });
+        }
+        const input = node.builder._inputMsgs;
+        const scope = node.builder._scope ? dependency_1.$Tag.parse(node.builder._scope) : undefined;
+        node.schema = new job_schema_1.$Job(node.builder.module, node.builder.name, node.builder._alias || node.builder.name, node.builder._authn, input, node.builder._output, node.builder._extrasAndAsserts, node.builder._method, scope ? {
+            module: node.builder.module,
+            machine: scope.name,
+        } : undefined);
+        return {
+            schema: node.schema,
+            inlineMessages: message_builder_1.MessageBuilder.buildInlines(node, tree, module)
+        };
+    }
+    // Build Inline
+    static buildInlines(node, tree, module, config) {
+        const nodeInlines = node.inlines.job || {};
+        const inlineJobs = {};
+        const nestedInlineMessages = {};
+        for (const name in nodeInlines || {}) {
+            const inline = nodeInlines[name];
+            const $j = inline.builder.$j;
+            if ($j === 'Job') {
+                const job = JobBuilder.build(inline, tree, module);
+                inlineJobs[name] = job.schema;
+                Object.assign(nestedInlineMessages, job.inlineMessages);
+            }
+            else if ($j === 'ResourceJob') {
+                const cfg = config[name].ResourceJob;
+                const job = resource_job_builder_1.ResourceJobBuilder.build(inline, tree, module, cfg.output, cfg.defaultTrigger, cfg.idType);
+                inlineJobs[name] = job.schema;
+                Object.assign(nestedInlineMessages, job.inlineMessages);
+            }
+            else if ($j === 'MachineJob') {
+                const cfg = config[name]?.MachineJob;
+                const job = machine_job_builder_1.MachineJobBuilder.build(inline, cfg?.input || []);
+                inlineJobs[name] = job;
+            }
+        }
+        return { inlineJobs, nestedInlineMessages };
+    }
+}
+exports.JobBuilder = JobBuilder;

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

@@ -0,0 +1,13 @@
+import { $Module, $Space } from "../../../schema";
+import { $Job } from './job.schema';
+import { Block } from '../block';
+import { AnyMessage } from "../../entities/message/message";
+import { Module } from "../../../engine/module";
+import { TrxNode } from "../../../engine/transaction/trx_node";
+export declare class Job<S extends $Space, M extends $Module, $ extends $Job> extends Block<S, M, $> {
+    module: Module<S, M>;
+    schema: $;
+    constructor(module: Module<S, M>, schema: $);
+    protected run(trx: TrxNode<S, M, $['#authn']>, msg: AnyMessage, _ctx?: Record<string, any>): Promise<$['#output']>;
+}
+export type AnyJob = Job<any, any, any>;

package/lib/elements/blocks/job/job.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Job = void 0;
+const block_1 = require("../block");
+const promise_1 = __importDefault(require("../../../engine/util/promise"));
+const message_1 = require("../../entities/message/message");
+const error_1 = require("../../../engine/data/error");
+class Job extends block_1.Block {
+    constructor(module, schema) {
+        super('job', module, schema);
+        this.module = module;
+        this.schema = schema;
+    }
+    async run(trx, msg, _ctx = {}) {
+        const _msg = message_1.Message.clone(msg);
+        const extra = {};
+        const ctx = { trx, msg: _msg, extra, job: this.schema };
+        Object.assign(ctx, _ctx);
+        for (const i in this.schema.extrasAndAsserts) {
+            const def = this.schema.extrasAndAsserts[i];
+            // Extra
+            if ('extra' in def) {
+                const extraInput = await promise_1.default.solve(def.extra(ctx));
+                Object.assign(extra, extraInput);
+            }
+            // Condition
+            else {
+                const condValue = await promise_1.default.solve(def.assert(ctx));
+                if (condValue !== true) {
+                    throw error_1.NesoiError.Job.ConditionUnmet({ job: this.schema.alias, error: condValue });
+                }
+            }
+        }
+        return this.schema.method(ctx);
+    }
+}
+exports.Job = Job;

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

@@ -0,0 +1,26 @@
+import { $Block, $BlockOutput } from '../block.schema';
+import { $Dependency } from "../../../engine/dependency";
+import { JobExtrasAndAsserts } from './job.builder';
+import { $ResourceJobScope } from './internal/resource_job.schema';
+import { $MachineJobScope } from '../machine/machine.schema';
+export type $JobAssert<Trx, Message, Extra = {}, Ctx = {}> = $JobMethod<Trx, Message, string | true, Extra, Ctx>;
+export type $JobMethod<Trx, Message, O, Extra = never, Ctx = {}> = (ctx: {
+    trx: Trx;
+    msg: Message;
+    extra: Extra;
+    job: $Job;
+} & Ctx) => O | Promise<O>;
+export declare class $Job extends $Block {
+    module: string;
+    name: string;
+    alias: string;
+    authn: string[];
+    input: $Dependency[];
+    output: $BlockOutput | undefined;
+    extrasAndAsserts: JobExtrasAndAsserts;
+    method: $JobMethod<any, any, any, any>;
+    scope?: ($MachineJobScope | $ResourceJobScope) | undefined;
+    $t: "job";
+    '#extra': unknown;
+    constructor(module: string, name: string, alias: string, authn: string[], input: $Dependency[], output: $BlockOutput | undefined, extrasAndAsserts: JobExtrasAndAsserts, method: $JobMethod<any, any, any, any>, scope?: ($MachineJobScope | $ResourceJobScope) | undefined);
+}

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$Job = void 0;
+const block_schema_1 = require("../block.schema");
+class $Job extends block_schema_1.$Block {
+    constructor(module, name, alias, authn, input, output, extrasAndAsserts, method, scope) {
+        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.extrasAndAsserts = extrasAndAsserts;
+        this.method = method;
+        this.scope = scope;
+        this.$t = 'job';
+    }
+}
+exports.$Job = $Job;

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

@@ -0,0 +1,58 @@
+import { $Module, $Space } from "../../../schema";
+import { $Machine, $MachineLogFn } from './machine.schema';
+import { MultiMessageTemplateDef } from "../../entities/message/template/message_template.builder";
+import { $MessageInfer } from "../../entities/message/message.infer";
+import { MachineStateDef } from './machine_state.builder';
+import { BlockBuilder } from '../block.builder';
+import { Overlay } from "../../../engine/util/type";
+import { ModuleTree } from "../../../engine/tree";
+import { ResolvedBuilderNode } from "../../../engine/dependency";
+export declare class MachineBuilder<Space extends $Space, Module extends $Module, Name extends string, $ extends $Machine = $Machine> extends BlockBuilder<Space, Module, 'machine'> {
+    $b: "machine";
+    private _buckets;
+    private _stateField;
+    private _stateAliasField?;
+    private _states;
+    private _logger?;
+    constructor(module: string, name: Name);
+    authn<U extends keyof Space['authnUsers']>(...providers: U[]): MachineBuilder<Space, Module, Name, Overlay<$, {
+        "#authn": { [K in U]: Space["authnUsers"][K]; };
+    }>>;
+    messages<Def extends MultiMessageTemplateDef<Space, Module>>(def: Def): MachineBuilder<Space, Overlay<Module, {
+        messages: Overlay<Module["messages"], { [K in keyof ReturnType<Def> as `${Name}${K extends "" ? "" : "."}${K & string}`]: $MessageInfer<`${Name}${K extends "" ? "" : "."}${K & string}`, ($: any) => ReturnType<Def>[K], ReturnType<Def>[K], import("../../entities/message/message.infer").$MessageInputInfer<ReturnType<Def>[K], ReturnType<Def>[K] extends infer T ? { [K_1 in keyof T]: ReturnType<Def>[K][K_1] extends import("../../entities/message/template/message_template_field.builder").MessageTemplateFieldBuilder<any, any, infer I, any, any, infer Opt extends [undefined, undefined], infer Nul extends [null, null]> ? {
+            path: `${K_1 & string}${keyof I & string}`;
+            data: I[keyof I];
+            opt: Opt[0];
+            nul: Nul[0];
+        } : never; } : never>, import("../../entities/message/message.infer").$MessageOutputInfer<ReturnType<Def>[K], ReturnType<Def>[K] extends infer T_1 ? { [K_2 in keyof T_1]: ReturnType<Def>[K][K_2] extends import("../../entities/message/template/message_template_field.builder").MessageTemplateFieldBuilder<any, any, any, infer O, any, infer Opt_1 extends [undefined, undefined], infer Nul_1 extends [null, null]> ? {
+            path: `${K_2 & string}${keyof O & string}`;
+            data: O[keyof O];
+            opt: Opt_1[1];
+            nul: Nul_1[1];
+        } : never; } : never>>; }>;
+    }>, Name, $>;
+    bucket<M extends keyof Module['buckets']>(names: M | M[]): MachineBuilder<Space, Module, Name, $ & {
+        "#data": Module["buckets"][M]["#data"];
+    }>;
+    stateField(key: {
+        [K in keyof $['#data']]: $['#data'][K] extends string ? K : never;
+    }[keyof $['#data']]): this;
+    stateAliasField(key: {
+        [K in keyof $['#data']]: $['#data'][K] extends string ? K : never;
+    }[keyof $['#data']]): this;
+    state<Name extends string, Def extends MachineStateDef<Space, Module, $, $['states'][Name]>>(name: Name, $?: Def): this;
+    logger($: $MachineLogFn<$>): this;
+    static build(node: MachineBuilderNode, tree: ModuleTree, module: $Module): {
+        schema: $Machine;
+        inlineMessages: {
+            [x: string]: import("../..").$Message;
+        };
+        inlineJobs: Record<string, import("../..").$Job>;
+    };
+}
+export type AnyMachineBuilder = MachineBuilder<any, any, any, any>;
+export type MachineDef = ($: AnyMachineBuilder) => any;
+export type MachineBuilderNode = Omit<ResolvedBuilderNode, 'builder'> & {
+    builder: AnyMachineBuilder;
+    schema?: $Machine;
+};