nesoi 3.2.8 → 3.3.0

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

@@ -11,7 +11,7 @@ import { BlockBuilder } from '../../block.builder';
 import { ResolvedBuilderNode } from "../../../../engine/dependency";
 import { NQL_AnyQuery } from "../../../entities/bucket/query/nql.schema";
 import { $Bucket } from "../../../entities/bucket/bucket.schema";
-import { $BlockOutput } from '../../block.schema';
+import { $BlockAuth, $BlockOutput } from '../../block.schema';
 export type ResourceAssertions<Bucket extends $Bucket> = {
     'query is empty': NQL_AnyQuery;
     'has no link': keyof Bucket['graph']['links'];
@@ -23,14 +23,14 @@ export type ResourceAssertionDef<Bucket extends $Bucket> = <T extends keyof Reso
  * @category Builders
  * @subcategory Block
  */
-export declare class ResourceJobBuilder<Space extends $Space, Module extends $Module, Name extends string, Prepared, Authn extends AnyUsers = {}, Bucket extends $Bucket = never, RequiredInput = {}, Trigger extends $Message = never, MsgExtras = {}, Ctx = {}, CtxAfter = {}> extends BlockBuilder<Space, Module, 'job'> {
+export declare class ResourceJobBuilder<Space extends $Space, Module extends $Module, Name extends string, Prepared, AuthUsers extends AnyUsers = {}, Bucket extends $Bucket = never, RequiredInput = {}, Trigger extends $Message = never, MsgExtras = {}, Ctx = {}, CtxAfter = {}> extends BlockBuilder<Space, Module, 'job'> {
     protected module: string;
     protected name: Name;
     protected bucket: string;
     protected method: 'view' | 'query' | 'create' | 'update' | 'delete';
     private alias;
     private execMethod?;
-    protected _authn: string[];
+    protected _auth: $BlockAuth[];
     private implicitFields;
     $b: "job";
     $j: "ResourceJob";
@@ -40,13 +40,14 @@ export declare class ResourceJobBuilder<Space extends $Space, Module extends $Mo
     private _extrasAndAsserts;
     private _prepareMethod;
     private _afterMethod?;
-    constructor(module: string, name: Name, bucket: string, method: 'view' | 'query' | 'create' | 'update' | 'delete', alias: string, execMethod?: $JobMethod<any, any, any, any> | undefined, _authn?: string[], implicitFields?: Record<string, [string, any, boolean]>);
+    constructor(module: string, name: Name, bucket: string, method: 'view' | 'query' | 'create' | 'update' | 'delete', alias: string, execMethod?: $JobMethod<any, any, any, any> | undefined, _auth?: $BlockAuth[], implicitFields?: Record<string, [string, any, boolean]>);
+    auth<U extends keyof Space['authnUsers']>(provider: U, resolver?: (user: Space['authnUsers'][U]) => boolean): ResourceJobBuilder<Space, Module, Name, Prepared, AuthUsers & { [K in U]: Space["authnUsers"][U]; }, Bucket, RequiredInput, Trigger, MsgExtras, Ctx, CtxAfter>;
     /**
      * The input message accepted by the job.
      *
      * @param def A `$ => ({})` definition for a custom trigger message
      */
-    input<Def extends MessageTemplateDef<Space, Module, Name>>(def: Def): ResourceJobBuilder<Space, Module, Name, Prepared, Authn, Bucket, RequiredInput, $MessageInfer<Name, any, ReturnType<Def> & { [K in keyof RequiredInput]: MessageTemplateFieldBuilder<any, any, any, {
+    input<Def extends MessageTemplateDef<Space, Module, Name>>(def: Def): ResourceJobBuilder<Space, Module, Name, Prepared, AuthUsers, Bucket, RequiredInput, $MessageInfer<Name, any, ReturnType<Def> & { [K in keyof RequiredInput]: MessageTemplateFieldBuilder<any, any, any, {
         '': RequiredInput[K];
     }, any, [false, false], "">; }, import("../../../entities/message/message.infer").$MessageInputInfer<ReturnType<Def> & { [K in keyof RequiredInput]: MessageTemplateFieldBuilder<any, any, any, {
         '': RequiredInput[K];
@@ -61,7 +62,7 @@ export declare class ResourceJobBuilder<Space extends $Space, Module extends $Mo
      */
     extra<Extra extends {
         [_: string]: any;
-    }, Trx = NoInfer<TrxNode<Space, Module, Authn>>, Msg = NoInfer<Trigger['#parsed']>, PreviousExtras = NoInfer<MsgExtras>, C = NoInfer<Ctx>>($: $JobMethod<Trx, Msg, Extra, PreviousExtras, C>): ResourceJobBuilder<Space, Module, Name, Prepared, Authn, Bucket, RequiredInput, Trigger, MsgExtras & Extra, Ctx, CtxAfter>;
+    }, Trx = NoInfer<TrxNode<Space, Module, AuthUsers>>, Msg = NoInfer<Trigger['#parsed']>, PreviousExtras = NoInfer<MsgExtras>, C = NoInfer<Ctx>>($: $JobMethod<Trx, Msg, Extra, PreviousExtras, C>): ResourceJobBuilder<Space, Module, Name, Prepared, AuthUsers, Bucket, RequiredInput, Trigger, MsgExtras & Extra, Ctx, CtxAfter>;
     /**
      * A function that checks a given condition over the input and throws an exception;
      * This assertion runs before the job method.
@@ -69,7 +70,7 @@ export declare class ResourceJobBuilder<Space extends $Space, Module extends $Mo
      * @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, Authn>>, Msg = NoInfer<Trigger['#parsed']>, Extras = NoInfer<MsgExtras>, C = NoInfer<Ctx & {
+    assert<Trx = NoInfer<TrxNode<Space, Module, AuthUsers>>, Msg = NoInfer<Trigger['#parsed']>, Extras = NoInfer<MsgExtras>, C = NoInfer<Ctx & {
         that: ResourceAssertionDef<Bucket>;
     }>>(condition: $JobAssert<Trx, Msg, Extras, C>): this;
     /**
@@ -77,20 +78,20 @@ export declare class ResourceJobBuilder<Space extends $Space, Module extends $Mo
      *
      * @param method A function which returns the required output.
      */
-    prepare<Trx = NoInfer<TrxNode<Space, Module, Authn>>, Msg = NoInfer<Trigger['#parsed']>, Extras = NoInfer<MsgExtras>, C = NoInfer<Ctx>>(method: $JobMethod<Trx, Msg, Prepared, Extras, C>): this;
+    prepare<Trx = NoInfer<TrxNode<Space, Module, AuthUsers>>, Msg = NoInfer<Trigger['#parsed']>, Extras = NoInfer<MsgExtras>, C = NoInfer<Ctx>>(method: $JobMethod<Trx, Msg, Prepared, Extras, C>): this;
     /**
      * The function called after the input has been processed.
      *
      * @param method A function which returns void.
      */
-    after<Trx = NoInfer<TrxNode<Space, Module, Authn>>, Msg = NoInfer<Trigger['#parsed']>, Extras = NoInfer<MsgExtras>, C = NoInfer<CtxAfter>>(method: $JobMethod<Trx, Msg, void, Extras, C>): this;
+    after<Trx = NoInfer<TrxNode<Space, Module, AuthUsers>>, Msg = NoInfer<Trigger['#parsed']>, Extras = NoInfer<MsgExtras>, C = NoInfer<CtxAfter>>(method: $JobMethod<Trx, Msg, void, Extras, C>): this;
     static build(node: ResourceJobBuilderNode, tree: ModuleTree, module: $Module, output: $BlockOutput, defaultTrigger: $Message, idType?: 'string' | 'int' | null): {
         schema: $Job;
         inlineMessages: Record<string, $Message>;
     };
 }
 export type AnyResourceJobBuilder = ResourceJobBuilder<any, any, any, any, any, any>;
-export type ResourceJobDef<S extends $Space, M extends $Module, Name extends string, Prepared, Authn extends AnyUsers, Bucket extends $Bucket, DefaultTrigger extends $Message = never, RequiredInput = {}, Ctx = {}, CtxAfter = {}> = ($: ResourceJobBuilder<S, M, Name, Prepared, Authn, Bucket, RequiredInput, DefaultTrigger, {}, Ctx, CtxAfter>) => any;
+export type ResourceJobDef<S extends $Space, M extends $Module, Name extends string, Prepared, AuthUsers extends AnyUsers, Bucket extends $Bucket, DefaultTrigger extends $Message = never, RequiredInput = {}, Ctx = {}, CtxAfter = {}> = ($: ResourceJobBuilder<S, M, Name, Prepared, AuthUsers, Bucket, RequiredInput, DefaultTrigger, {}, Ctx, CtxAfter>) => any;
 export type ResourceJobBuilderNode = Omit<ResolvedBuilderNode, 'builder'> & {
     builder: AnyResourceJobBuilder;
     schema?: $Job;

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

@@ -13,7 +13,7 @@ const resource_job_1 = require("./resource_job");
  * @subcategory Block
  */
 class ResourceJobBuilder extends block_builder_1.BlockBuilder {
-    constructor(module, name, bucket, method, alias, execMethod, _authn = [], implicitFields = {}) {
+    constructor(module, name, bucket, method, alias, execMethod, _auth = [], implicitFields = {}) {
         super(module, 'job', name);
         this.module = module;
         this.name = name;
@@ -21,7 +21,7 @@ class ResourceJobBuilder extends block_builder_1.BlockBuilder {
         this.method = method;
         this.alias = alias;
         this.execMethod = execMethod;
-        this._authn = _authn;
+        this._auth = _auth;
         this.implicitFields = implicitFields;
         this.$b = 'job';
         this.$j = 'ResourceJob';
@@ -32,15 +32,17 @@ class ResourceJobBuilder extends block_builder_1.BlockBuilder {
             .as(alias);
         super._input(name);
         this._inlineNodes.push(new dependency_1.BuilderNode({
-            module: this.module,
-            type: 'message',
-            name: name,
+            tag: new dependency_1.Tag(this.module, 'message', name),
             builder: this._msg,
             isInline: true,
             filepath: [], // This is added later by Treeshake.blockInlineNodes()
             dependencies: [] // This is added later by Treeshake.*()
         }));
     }
+    /* [Block] */
+    auth(provider, resolver) {
+        return super.auth(provider, resolver);
+    }
     /**
      * The input message accepted by the job.
      *
@@ -127,7 +129,8 @@ class ResourceJobBuilder extends block_builder_1.BlockBuilder {
                 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, {
+        const msgTag = node.builder._inlineNodes[0].tag;
+        node.schema = new job_schema_1.$Job(node.builder.module, node.builder.name, node.builder.alias || node.builder.name, node.builder._auth, [msgTag], output, node.builder._extrasAndAsserts, resource_job_1.ResourceJob.method, {
             module: node.builder.module,
             resource: node.builder.resource,
             bucket: node.builder.bucket,

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

@@ -1,27 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResourceJob = void 0;
-const trx_node_1 = require("../../../../engine/transaction/trx_node");
 /**
  * @category Elements
  * @subcategory Block
  */
 class ResourceJob {
     static async method($) {
-        // Check authentication
-        trx_node_1.TrxNode.checkAuthn($.trx, $.job.authn);
         // 
         const id = $.msg.id;
         const scope = $.job.scope;
         let obj = $.obj;
         obj = await scope.prepareMethod({ ...$, obj, bucket: scope.bucket });
         // Preserve the original message ID (if any),
-        // even if the prepare method doesn't add it
-        if (scope.method === 'create' || scope.method === 'update') {
+        // if the prepare method mistakenly changed it
+        if (scope.method === 'update') {
             obj.id = id;
         }
         // On delete, the method returns a boolean, so replace it with the id. 
-        else {
+        else if (scope.method === 'delete') {
             if (!obj)
                 return;
             obj = { id };

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

@@ -6,7 +6,7 @@ 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 { ResolvedBuilderNode, Tag } from "../../../engine/dependency";
 import { $Message } from "../../entities/message/message.schema";
 import { $BlockOutput } from '../block.schema';
 export type JobExtrasAndAsserts = ({
@@ -27,10 +27,10 @@ export declare class JobBuilder<Space extends $Space, Module extends $Module, Jo
     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]; };
+    auth<U extends keyof Space['authnUsers']>(provider: U, resolver?: (user: Space['authnUsers'][U]) => boolean): JobBuilder<Space, Module, Overlay<Job, {
+        "#authn": 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, {
+    scope<MachineName extends keyof Module['machines'] & string, JobScope extends `machine:${MachineName}`, Machine extends NoInfer<Module['machines'][MachineName]>>(scope: JobScope): JobBuilder<Space, Module, Job, {
         obj: Machine["#data"];
         from: keyof Machine["states"] & string;
         to: keyof Machine["states"] & string;
@@ -109,7 +109,7 @@ export type JobBuildConfig = {
             defaultTrigger: $Message;
         };
         MachineJob?: {
-            input: $Dependency[];
+            input: Tag[];
         };
     };
 };

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

@@ -8,7 +8,7 @@ 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");
-const name_helpers_1 = require("../../../compiler/helpers/name_helpers");
+const name_helpers_1 = require("../../../engine/util/name_helpers");
 /**
  * @category Builders
  * @subcategory Block
@@ -21,12 +21,12 @@ class JobBuilder extends block_builder_1.BlockBuilder {
         this._extrasAndAsserts = [];
     }
     /* [Block] */
-    authn(...providers) {
-        return super.authn(...providers);
+    auth(provider, resolver) {
+        return super.auth(provider, resolver);
     }
     /* [Scope] */
     scope(scope) {
-        this._scope = scope;
+        this._scope = new dependency_1.Tag(this.module, 'machine', scope.split(':')[1]);
         // Machine-scoped job
         return this;
     }
@@ -101,9 +101,9 @@ class JobBuilder extends block_builder_1.BlockBuilder {
         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 ? {
+        const input = node.builder._inputMsgs.map(m => m.tag);
+        const scope = node.builder._scope;
+        node.schema = new job_schema_1.$Job(node.builder.module, node.builder.name, node.builder._alias || node.builder.name, node.builder._auth, input, node.builder._output, node.builder._extrasAndAsserts, node.builder._method, scope ? {
             module: node.builder.module,
             machine: scope.name,
         } : undefined);

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

@@ -21,7 +21,7 @@ class Job extends block_1.Block {
     }
     async run(trx, msg, _ctx = {}) {
         // Check authentication
-        trx_node_1.TrxNode.checkAuthn(trx, this.schema.authn);
+        await trx_node_1.TrxNode.checkAuth(trx, this.schema.auth);
         const _msg = message_1.Message.clone(msg);
         const extra = {};
         const ctx = { trx, msg: _msg, extra, job: this.schema };

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

@@ -1,5 +1,5 @@
-import { $Block, $BlockOutput } from '../block.schema';
-import { $Dependency } from "../../../engine/dependency";
+import { $Block, $BlockOutput, $BlockAuth } from '../block.schema';
+import { Tag } from "../../../engine/dependency";
 import { JobExtrasAndAsserts } from './job.builder';
 import { $ResourceJobScope } from './internal/resource_job.schema';
 import { $MachineJobScope } from '../machine/machine.schema';
@@ -18,13 +18,13 @@ export declare class $Job extends $Block {
     module: string;
     name: string;
     alias: string;
-    authn: string[];
-    input: $Dependency[];
+    auth: $BlockAuth[];
+    input: Tag[];
     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);
+    constructor(module: string, name: string, alias: string, auth: $BlockAuth[], input: Tag[], output: $BlockOutput | undefined, extrasAndAsserts: JobExtrasAndAsserts, method: $JobMethod<any, any, any, any>, scope?: ($MachineJobScope | $ResourceJobScope) | undefined);
 }

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

@@ -7,12 +7,12 @@ const block_schema_1 = require("../block.schema");
  * @subcategory Block
  */
 class $Job extends block_schema_1.$Block {
-    constructor(module, name, alias, authn, input, output, extrasAndAsserts, method, scope) {
-        super(module, name, alias, authn, input, output);
+    constructor(module, name, alias, auth, input, output, extrasAndAsserts, method, scope) {
+        super(module, name, alias, auth, input, output);
         this.module = module;
         this.name = name;
         this.alias = alias;
-        this.authn = authn;
+        this.auth = auth;
         this.input = input;
         this.output = output;
         this.extrasAndAsserts = extrasAndAsserts;

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

@@ -20,8 +20,8 @@ export declare class MachineBuilder<Space extends $Space, Module extends $Module
     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]; };
+    auth<U extends keyof Space['authnUsers']>(provider: U, resolver?: (user: Space['authnUsers'][U]) => boolean): MachineBuilder<Space, Module, Name, Overlay<$, {
+        "#authn": $["#authn"] & { [K in U]: Space["authnUsers"][K]; };
     }>>;
     message<Name extends string, Def extends MessageTemplateDef<Space, Module, Name>, FullName extends string = `${$['name']}${Name extends '' ? '' : '.'}${Name & string}`, Msg extends $Message = $MessageInfer<FullName, ($: any) => ReturnType<Def>>>(name: Name, def: Def): MachineBuilder<Space, Overlay<Module, {
         messages: Overlay<Module["messages"], { [K in FullName]: Msg; }>;

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

@@ -20,8 +20,8 @@ class MachineBuilder extends block_builder_1.BlockBuilder {
         this._states = {};
     }
     /* [Block] */
-    authn(...providers) {
-        return super.authn(...providers);
+    auth(provider, resolver) {
+        return super.auth(provider, resolver);
     }
     message(name, def) {
         return super.message(name, def);
@@ -29,7 +29,10 @@ class MachineBuilder extends block_builder_1.BlockBuilder {
     /* [Data] */
     bucket(names) {
         names = Array.isArray(names) ? names : [names];
-        this._buckets = names.map(name => new dependency_1.$Dependency(this.module, 'bucket', name));
+        this._buckets = names.map(name => {
+            const tag = dependency_1.Tag.fromNameOrShort(this.module, 'bucket', name);
+            return new dependency_1.Dependency(this.module, tag, { compile: true, runtime: true });
+        });
         return this;
     }
     stateField(key) {
@@ -78,7 +81,7 @@ class MachineBuilder extends block_builder_1.BlockBuilder {
             Object.values(msgTransitions)
                 .flat(1)
                 .forEach(t => {
-                if (!states[state].input.some(dep => dep.tag === t.msg.tag)) {
+                if (!states[state].input.some(tag => tag.full === t.msg.full)) {
                     states[state].input.push(t.msg);
                 }
             });
@@ -88,16 +91,16 @@ class MachineBuilder extends block_builder_1.BlockBuilder {
             .flat(1);
         const jobs = [];
         Object.values(states).forEach(state => {
-            jobs.push(...Object.values(state.jobs));
+            jobs.push(...Object.values(state.jobs).filter(j => !!j));
         });
         Object.values(transitions.from).forEach(stateTransitions => {
             Object.values(stateTransitions).forEach(transitionList => {
                 transitionList.forEach(trans => {
-                    jobs.push(...trans.jobs);
+                    jobs.push(...trans.jobs.filter(j => !!j));
                 });
             });
         });
-        node.schema = new machine_schema_1.$Machine(node.builder.module, node.builder.name, node.builder._alias || node.builder.name, node.builder._authn, input, node.builder._buckets, jobs, node.builder._stateField || 'state', states, transitions, node.builder._stateAliasField, node.builder._logger);
+        node.schema = new machine_schema_1.$Machine(node.builder.module, node.builder.name, node.builder._alias || node.builder.name, node.builder._auth, input, node.builder._buckets.map(b => b.tag), jobs, node.builder._stateField || 'state', states, transitions, node.builder._stateAliasField, node.builder._logger);
         // Configure state jobs with proper input, based on transition targets
         const inlineJobsConfig = {};
         Object.values(states).forEach(state => {
@@ -105,13 +108,13 @@ class MachineBuilder extends block_builder_1.BlockBuilder {
             const inputLeave = [];
             Object.values(transFrom)
                 .flat(1)
-                .filter($t => !inputLeave.some(dep => dep.tag === $t.msg.tag))
+                .filter($t => !inputLeave.some(tag => dependency_1.Tag.matches(tag, $t.msg)))
                 .forEach($t => inputLeave.push($t.msg));
             const transTo = transitions.to[state.name] || {};
             const inputEnter = [];
             Object.values(transTo)
                 .flat(1)
-                .filter($t => !inputEnter.some(dep => dep.tag === $t.msg.tag))
+                .filter($t => !inputEnter.some(tag => dependency_1.Tag.matches(tag, $t.msg)))
                 .forEach($t => inputEnter.push($t.msg));
             state.inputEnter = inputEnter;
             state.inputLeave = inputLeave;

package/lib/elements/blocks/machine/machine.js

@@ -133,7 +133,7 @@ class Machine extends block_1.Block {
         let bucketUsed;
         let obj;
         for (const bucket of this.schema.buckets) {
-            obj = await trx.bucket(bucket.refName).readOne(msg.id);
+            obj = await trx.bucket(bucket.short).readOne(msg.id);
             if (obj) {
                 bucketUsed = bucket;
                 break;
@@ -184,12 +184,12 @@ class Machine extends block_1.Block {
             }
             // Run all transition jobs
             for (const job of transition.jobs) {
-                await trx_node_1.TrxNode.jobWithCustomCtx(trx, job.refName, {
+                await trx_node_1.TrxNode.jobWithCustomCtx(trx, job.short, {
                     obj,
                     from: state.name,
                     to: nextState.name
                 }).forward(msg);
-                MachineOutput.add(output, MachineOutputEntry.info_job_from_transition(job.tag, transition.name));
+                MachineOutput.add(output, MachineOutputEntry.info_job_from_transition(job.full, transition.name));
             }
             // Run "beforeEnter" job of next state
             await this.runStateJob(trx, output, queue, nextState.jobs.beforeEnter, msg, obj, state.name, nextState.name, 'before_enter', `Ran job '${nextState.jobs.beforeEnter?.name}' before entering '${nextState.name}'`);
@@ -199,7 +199,7 @@ class Machine extends block_1.Block {
             if (this.schema.stateAliasField) {
                 obj[this.schema.stateAliasField] = nextState.alias;
             }
-            obj = await trx.bucket(bucketUsed.refName).patch(obj);
+            obj = await trx.bucket(bucketUsed.short).patch(obj);
             if (nextStateName !== stateName) {
                 MachineOutput.add(output, MachineOutputEntry.info_state_changed(state.name, nextState.name));
             }
@@ -226,15 +226,15 @@ class Machine extends block_1.Block {
         if (!job) {
             return;
         }
-        const result = await trx_node_1.TrxNode.jobWithCustomCtx(trx, job.refName, {
+        const result = await trx_node_1.TrxNode.jobWithCustomCtx(trx, job.short, {
             obj,
             from,
             to
         }).forward(msg);
-        MachineOutput.add(output, MachineOutputEntry.info_job_from_state(job.tag, from));
+        MachineOutput.add(output, MachineOutputEntry.info_job_from_state(job.full, from));
         if (result instanceof message_1.Message) {
             queue.push(result);
-            MachineOutput.add(output, MachineOutputEntry.info_job_returned_message(job.tag, result));
+            MachineOutput.add(output, MachineOutputEntry.info_job_returned_message(job.full, result));
         }
     }
 }

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

@@ -1,6 +1,6 @@
-import { $Block } from "../block.schema";
+import { $Block, $BlockAuth } from "../block.schema";
 import { $JobAssert } from "../job/job.schema";
-import { $Dependency } from "../../../engine/dependency";
+import { Tag } from "../../../engine/dependency";
 import { AnyTrxNode } from "../../../engine/transaction/trx_node";
 import { MachineOutput } from './machine';
 /**
@@ -11,14 +11,14 @@ export declare class $MachineTransition extends $Block {
     module: string;
     name: string;
     alias: string;
-    authn: string[];
-    msg: $Dependency;
+    auth: $BlockAuth[];
+    msg: Tag;
     from: string;
     to: string;
     condition?: $JobAssert<any, any, never, any> | undefined;
-    jobs: $Dependency[];
+    jobs: Tag[];
     $t: any;
-    constructor(module: string, name: string, alias: string, authn: string[], msg: $Dependency, from: string, to: string, condition?: $JobAssert<any, any, never, any> | undefined, jobs?: $Dependency[]);
+    constructor(module: string, name: string, alias: string, auth: $BlockAuth[], msg: Tag, from: string, to: string, condition?: $JobAssert<any, any, never, any> | undefined, jobs?: Tag[]);
 }
 export type $MachineTransitions = {
     from: {
@@ -40,25 +40,25 @@ export declare class $MachineState extends $Block {
     module: string;
     name: string;
     alias: string;
-    authn: string[];
+    auth: $BlockAuth[];
     initial: boolean;
     final: boolean;
-    inputEnter: $Dependency[];
-    inputLeave: $Dependency[];
+    inputEnter: Tag[];
+    inputLeave: Tag[];
     jobs: {
-        beforeEnter?: $Dependency;
-        afterEnter?: $Dependency;
-        beforeLeave?: $Dependency;
-        afterLeave?: $Dependency;
+        beforeEnter?: Tag;
+        afterEnter?: Tag;
+        beforeLeave?: Tag;
+        afterLeave?: Tag;
     };
     $t: any;
     '#input.enter': any;
     '#input.leave': any;
-    constructor(module: string, name: string, alias: string, authn: string[], initial: boolean, final: boolean, inputEnter: $Dependency[], inputLeave: $Dependency[], jobs: {
-        beforeEnter?: $Dependency;
-        afterEnter?: $Dependency;
-        beforeLeave?: $Dependency;
-        afterLeave?: $Dependency;
+    constructor(module: string, name: string, alias: string, auth: $BlockAuth[], initial: boolean, final: boolean, inputEnter: Tag[], inputLeave: Tag[], jobs: {
+        beforeEnter?: Tag;
+        afterEnter?: Tag;
+        beforeLeave?: Tag;
+        afterLeave?: Tag;
     });
 }
 export type $MachineStates = {
@@ -72,10 +72,10 @@ export declare class $Machine extends $Block {
     module: string;
     name: string;
     alias: string;
-    authn: string[];
-    input: $Dependency[];
-    buckets: $Dependency[];
-    jobs: $Dependency[];
+    auth: $BlockAuth[];
+    input: Tag[];
+    buckets: Tag[];
+    jobs: Tag[];
     stateField: string;
     states: $MachineStates;
     transitions: $MachineTransitions;
@@ -83,7 +83,7 @@ export declare class $Machine extends $Block {
     logger?: $MachineLogFn<any> | undefined;
     $t: "machine";
     '#data': unknown;
-    constructor(module: string, name: string, alias: string, authn: string[], input: $Dependency[], buckets: $Dependency[], jobs: $Dependency[], stateField: string, states: $MachineStates, transitions: $MachineTransitions, stateAliasField?: string | undefined, logger?: $MachineLogFn<any> | undefined);
+    constructor(module: string, name: string, alias: string, auth: $BlockAuth[], input: Tag[], buckets: Tag[], jobs: Tag[], stateField: string, states: $MachineStates, transitions: $MachineTransitions, stateAliasField?: string | undefined, logger?: $MachineLogFn<any> | undefined);
 }
 /**
  * @category Schemas

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

@@ -8,12 +8,12 @@ const block_schema_1 = require("../block.schema");
  * @subcategory Block
  */
 class $MachineTransition extends block_schema_1.$Block {
-    constructor(module, name, alias, authn, msg, from, to, condition, jobs = []) {
-        super(module, name, alias, authn, [msg], {});
+    constructor(module, name, alias, auth, msg, from, to, condition, jobs = []) {
+        super(module, name, alias, auth, [msg], {});
         this.module = module;
         this.name = name;
         this.alias = alias;
-        this.authn = authn;
+        this.auth = auth;
         this.msg = msg;
         this.from = from;
         this.to = to;
@@ -29,12 +29,12 @@ exports.$MachineTransition = $MachineTransition;
  * @subcategory Block
  */
 class $MachineState extends block_schema_1.$Block {
-    constructor(module, name, alias, authn, initial, final, inputEnter, inputLeave, jobs) {
-        super(module, name, alias, authn, [...inputEnter, ...inputLeave], {});
+    constructor(module, name, alias, auth, initial, final, inputEnter, inputLeave, jobs) {
+        super(module, name, alias, auth, [...inputEnter, ...inputLeave], {});
         this.module = module;
         this.name = name;
         this.alias = alias;
-        this.authn = authn;
+        this.auth = auth;
         this.initial = initial;
         this.final = final;
         this.inputEnter = inputEnter;
@@ -49,12 +49,12 @@ exports.$MachineState = $MachineState;
  * @subcategory Block
  */
 class $Machine extends block_schema_1.$Block {
-    constructor(module, name, alias, authn, input, buckets, jobs, stateField, states, transitions, stateAliasField, logger) {
-        super(module, name, alias, authn, input, {});
+    constructor(module, name, alias, auth, input, buckets, jobs, stateField, states, transitions, stateAliasField, logger) {
+        super(module, name, alias, auth, input, {});
         this.module = module;
         this.name = name;
         this.alias = alias;
-        this.authn = authn;
+        this.auth = auth;
         this.input = input;
         this.buckets = buckets;
         this.jobs = jobs;

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

@@ -60,3 +60,4 @@ export declare class MachineStateBuilder<S extends $Space, M extends $Module, $M
     };
 }
 export type MachineStateDef<S extends $Space, M extends $Module, $M extends $Machine, State extends $MachineState> = ($: MachineStateBuilder<S, M, $M, State>) => any;
+export type AnyMachineStateBuilder = MachineStateBuilder<any, any, any, any>;