nesoi 3.2.8 → 3.3.0

package/lib/compiler/typescript/error.js

@@ -33,233 +33,20 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypegenError = exports.HelperError = exports.ResourceParserError = exports.JobParserError = exports.BucketParserError = exports.EnumParserError = exports.MsgParserError = exports.ControllerParserError = exports.ConstParserError = exports.ParserError = exports.MetaError = void 0;
+exports.TypescriptParserError = void 0;
 const ts = __importStar(require("typescript"));
-class MetaError extends Error {
-    constructor(message) {
-        super(message);
-    }
-    static DirectoryDoesntExists(dir) {
-        return new MetaError(`Directory doesnt exists: ${dir}.`);
-    }
-    static FileDoesntExist(path) {
-        return new MetaError(`File doesn't exist: ${path}`);
-    }
-    static NoModulesFolder() {
-        return new MetaError('No modules folder found on project root.');
-    }
-}
-exports.MetaError = MetaError;
-class ParserError extends Error {
+class TypescriptParserError extends Error {
     constructor(message) {
         super(message);
     }
     static ObjectPropertyIsNotAssignment() {
-        return new MetaError('Object property is not an assignment.');
+        return new TypescriptParserError('Object property is not an assignment.');
     }
     static StrangeValueKind(kind) {
-        throw new MetaError(`Strange value kind ${ts.SyntaxKind[kind]}`);
+        throw new TypescriptParserError(`Strange value kind ${ts.SyntaxKind[kind]}`);
     }
     static StrangeTypeKind(kind) {
-        throw new MetaError(`Strange type kind ${ts.SyntaxKind[kind]}`);
-    }
-}
-exports.ParserError = ParserError;
-class ConstParserError extends Error {
-    constructor(message) {
-        super(message);
-    }
-    static ConstValueIsWrongKind(kind) {
-        throw new MetaError(`Constant value is of wrong kind (${kind})`);
-    }
-    static ConstValueIsStrange() {
-        throw new MetaError('Constant value should be $.static or $.app');
-    }
-    static ConstEnumIsWrongKind(kind) {
-        throw new MetaError(`Constant enum is of wrong kind (${kind})`);
-    }
-    static ConstEnumReturnIsWrongKind(kind) {
-        throw new MetaError(`Constant enum return is of wrong kind (${kind})`);
-    }
-    static ConstEnumOptionIsWrongKind(kind) {
-        throw new MetaError(`Constant enum option is of wrong kind (${kind})`);
-    }
-    static ConstEnumOptionIsStrange() {
-        throw new MetaError('Constant enum option should be $.opt');
-    }
-}
-exports.ConstParserError = ConstParserError;
-class ControllerParserError extends Error {
-    constructor(message) {
-        super(message);
-    }
-    static ControllerIsWrongKind(kind) {
-        throw new MetaError(`Controller is of wrong kind (${kind})`);
-    }
-    static ControllerEndpointIsWrongKind(kind) {
-        throw new MetaError(`Controller endpoint is of wrong kind (${kind})`);
-    }
-    static ControllerEndpointDefIsWrongKind(kind) {
-        throw new MetaError(`Controller endpoint def is of wrong kind (${kind})`);
-    }
-    static ControllerEndpointHasNoName() {
-        throw new MetaError('Controller endpoint has no name');
-    }
-    static ControllerEndpointHasNoMessage() {
-        throw new MetaError('Controller endpoint declares no .msg()');
-    }
-    static ControllerGroupIsWrongKind(kind) {
-        throw new MetaError(`Controller group is of wrong kind (${kind})`);
-    }
-    static ControllerGroupHasNoName() {
-        throw new MetaError('Controller group has no name');
-    }
-    static ControllerGroupDefIsWrongKind(kind) {
-        throw new MetaError(`Controller group def is of wrong kind (${kind})`);
-    }
-}
-exports.ControllerParserError = ControllerParserError;
-class MsgParserError extends Error {
-    constructor(message) {
-        super(message);
-    }
-    static MessageHasNoTemplate() {
-        throw new MetaError('Message has no template');
-    }
-    static MessageTemplateIsWrongKind(kind) {
-        throw new MetaError(`Message template is of wrong kind (${kind})`);
-    }
-    static MessageTemplateFieldIsWrongKind(kind) {
-        throw new MetaError(`Message template field is of wrong kind (${kind})`);
-    }
-    static MessageTemplateFieldHasNoType() {
-        throw new MetaError('Message template field has no type');
-    }
-    static MessageMultiTemplateIsWrongKind(kind) {
-        throw new MetaError(`Message multi template is of wrong kind (${kind})`);
-    }
-    static MessageTemplateFieldEnumIsWrongKind(kind) {
-        throw new MetaError(`Message template field enum is of wrong kind (${kind})`);
-    }
-}
-exports.MsgParserError = MsgParserError;
-class EnumParserError extends Error {
-    constructor(message) {
-        super(message);
-    }
-    static ModelFieldEnumIsWrongKind(kind) {
-        throw new MetaError(`Model field enum is of wrong kind (${kind})`);
-    }
-}
-exports.EnumParserError = EnumParserError;
-class BucketParserError extends Error {
-    constructor(message) {
-        super(message);
-    }
-    static BucketHasNoModel() {
-        throw new MetaError('Bucket has no model');
-    }
-    static BucketModelIsWrongKind(kind) {
-        throw new MetaError(`Bucket model is of wrong kind (${kind})`);
-    }
-    static BucketModelFieldIsWrongKind(kind) {
-        throw new MetaError(`Bucket model field is of wrong kind (${kind})`);
-    }
-    static BucketModelFieldHasNoType() {
-        throw new MetaError('Bucket model field has no type');
-    }
-    static BucketHasNoGraph() {
-        throw new MetaError('Bucket has no graph');
-    }
-    static BucketGraphIsWrongKind(kind) {
-        throw new MetaError(`Bucket graph is of wrong kind (${kind})`);
-    }
-    static BucketGraphLinkIsWrongKind(kind) {
-        throw new MetaError(`Bucket graph field is of wrong kind (${kind})`);
-    }
-    static BucketGraphLinkHasNoType() {
-        throw new MetaError('Bucket graph field has no type');
-    }
-    static BucketGraphLinkInvalid() {
-        throw new MetaError('Bucket graph link is invalid');
-    }
-    static BucketHasNoView() {
-        throw new MetaError('Bucket has no view');
-    }
-    static BucketViewHasNoTemplate() {
-        throw new MetaError('Bucket view has no template');
-    }
-    static BucketViewIsWrongKind(kind) {
-        throw new MetaError(`Bucket view is of wrong kind (${kind})`);
-    }
-    static BucketViewFieldIsWrongKind(kind) {
-        throw new MetaError(`Bucket view field is of wrong kind (${kind})`);
-    }
-    static BucketViewFieldHasNoType() {
-        throw new MetaError('Bucket view field has no type');
-    }
-    static BucketViewFieldInvalid() {
-        throw new MetaError('Bucket view field is invalid');
-    }
-}
-exports.BucketParserError = BucketParserError;
-class JobParserError extends Error {
-    constructor(message) {
-        super(message);
-    }
-    static JobHasNoTemplate() {
-        throw new MetaError('Job has no template');
-    }
-    static JobTemplateIsWrongKind(kind) {
-        throw new MetaError(`Job template is of wrong kind (${kind})`);
-    }
-    static JobTemplateFieldIsWrongKind(kind) {
-        throw new MetaError(`Job template field is of wrong kind (${kind})`);
-    }
-    static JobTemplateFieldHasNoType() {
-        throw new MetaError('Job template field has no type');
-    }
-    static JobAuthnHasInvalidValue() {
-        throw new MetaError('Job authn has invalid value');
-    }
-}
-exports.JobParserError = JobParserError;
-class ResourceParserError extends Error {
-    constructor(message) {
-        super(message);
-    }
-    static ResourceJobInputHasNoTemplate() {
-        throw new MetaError('Resource job input has no template');
-    }
-}
-exports.ResourceParserError = ResourceParserError;
-class HelperError extends Error {
-    constructor(message) {
-        super(message);
-    }
-    static ArrayElementIsNotString(kind) {
-        throw new MetaError(`Array element is not a string (${kind})`);
-    }
-    static NotAStringOrArray(kind) {
-        throw new MetaError(`Not a string or array (${kind})`);
-    }
-    static StringIsUndefined() {
-        throw new MetaError('String is undefined');
-    }
-    static NotAString(kind) {
-        throw new MetaError(`Not a string (${kind})`);
-    }
-}
-exports.HelperError = HelperError;
-class TypegenError extends Error {
-    constructor(message) {
-        super(message);
-    }
-    static BuildMethodNotCalled(context) {
-        return new MetaError(`Build method not called on ${context}.`);
-    }
-    static Resource_BucketRequired(context) {
-        return new MetaError(`Resource ${context} should specify a bucket.`);
+        throw new TypescriptParserError(`Strange type kind ${ts.SyntaxKind[kind]}`);
     }
 }
-exports.TypegenError = TypegenError;
+exports.TypescriptParserError = TypescriptParserError;

package/lib/compiler/typescript/parser.js

@@ -294,7 +294,7 @@ class Parser {
             return new ParsedNode(node, 'value', 'token', '??');
         }
         console.error(node.getText());
-        throw error_1.ParserError.StrangeValueKind(node.kind);
+        throw error_1.TypescriptParserError.StrangeValueKind(node.kind);
     }
     static parseObjectMembers(node) {
         if (DEBUG_LOG)
@@ -306,7 +306,7 @@ class Parser {
                 continue;
             }
             if (!ts.isPropertyAssignment(prop)) {
-                throw error_1.ParserError.ObjectPropertyIsNotAssignment();
+                throw error_1.TypescriptParserError.ObjectPropertyIsNotAssignment();
             }
             const name = Parser.parseNode(prop.name).value;
             properties[name] = Parser.parseNode(prop.initializer);
@@ -558,7 +558,7 @@ class Parser {
             return new ParsedNode(node, 'type', 'identifier', this.parseNode(node.typeName)?.value);
         }
         console.error(node);
-        throw error_1.ParserError.StrangeTypeKind(node.kind);
+        throw error_1.TypescriptParserError.StrangeTypeKind(node.kind);
     }
     static parseTypeMembers(nodes) {
         const parsed = {};

package/lib/compiler/typescript/source.d.ts

@@ -1,12 +1,12 @@
 import * as ts from 'typescript';
-import { BuilderType } from "../../schema";
+import { ElementType } from "../../schema";
 export declare class MetaSource {
     sourceFile: ts.SourceFile;
     filename: string;
     imports: ts.ImportDeclaration[];
     interfaces: Record<string, ts.InterfaceDeclaration>;
     newExpressions: ts.NewExpression[];
-    nesoiCallExpressions: Partial<Record<BuilderType, Record<string, ts.CallExpression>>>;
+    nesoiCallExpressions: Partial<Record<ElementType, Record<string, ts.CallExpression>>>;
     constructor(sourceFile: ts.SourceFile);
     private parseFile;
 }

package/lib/compiler/typescript/transformers/app_inject.transformer.js

@@ -39,12 +39,15 @@ const parser_1 = require("../parser");
 function makeAppInjectTransformer(modules) {
     // @ts-expect-error This is according to documentation, but the type is broken for some reason
     const transformer = (context) => {
+        let esnext = false;
         const visit = (node) => {
             // Find leaf node of builder which is a NewExpression
             if (ts.isNewExpression(node)) {
-                if (parser_1.Parser.parseNode(node.expression).value !== 'MonolythApp') {
+                const name = parser_1.Parser.parseNode(node.expression).value;
+                if (name !== 'MonolythApp' && name !== 'BrowserApp') {
                     return { monolyth: false, node };
                 }
+                esnext = name === 'BrowserApp';
                 return {
                     monolyth: true,
                     node: ts.factory.updateNewExpression(node, node.expression, node.typeArguments, [
@@ -69,9 +72,15 @@ function makeAppInjectTransformer(modules) {
                 return {
                     monolyth: true,
                     node: ts.factory.updateCallExpression(cNode, ts.factory.updatePropertyAccessExpression(cNode.expression, cNode.expression.expression, ts.factory.createIdentifier('inject')), cNode.typeArguments, [
-                        ts.factory.createArrayLiteralExpression(modules.map(module => ts.factory.createPropertyAccessExpression(ts.factory.createCallExpression(ts.factory.createIdentifier('require'), undefined, [
-                            ts.factory.createStringLiteral(`./modules/${module}`, true)
-                        ]), ts.factory.createIdentifier('default'))), true)
+                        ts.factory.createArrayLiteralExpression(modules.map(module => esnext
+                            // (await import('...')).default
+                            ? ts.factory.createPropertyAccessExpression(ts.factory.createParenthesizedExpression(ts.factory.createAwaitExpression(ts.factory.createCallExpression(ts.factory.createIdentifier('import'), undefined, [
+                                ts.factory.createStringLiteral(`./modules/${module}`, true)
+                            ]))), ts.factory.createIdentifier('default'))
+                            // require('...').default
+                            : ts.factory.createPropertyAccessExpression(ts.factory.createCallExpression(ts.factory.createIdentifier('require'), undefined, [
+                                ts.factory.createStringLiteral(`./modules/${module}`, true)
+                            ]), ts.factory.createIdentifier('default'))), true)
                     ])
                 };
             }

package/lib/compiler/typescript/typescript_compiler.d.ts

@@ -1,6 +1,6 @@
 import * as ts from 'typescript';
 import { AnySpace } from "../../engine/space";
-import { BuilderType } from "../../schema";
+import { ElementType } from "../../schema";
 export type tsQueryResult<T = ts.Node> = {
     path: string;
     node: T;
@@ -33,14 +33,14 @@ export declare class TypeScriptCompiler {
     private runQuery;
     getReturnNode(node: ts.FunctionExpression | ts.ArrowFunction): ts.Expression | undefined;
     getReturnType(node: ts.FunctionExpression | ts.ArrowFunction): string;
-    getFnText(node: ts.FunctionExpression | ts.ArrowFunction): string;
+    getFnText(node: ts.FunctionExpression | ts.ArrowFunction, type?: string): string;
     getFnType(node: ts.FunctionExpression | ts.ArrowFunction): string;
     getCallName(node: ts.Node): ts.__String | undefined;
     isCall(node: ts.Node, from: ts.Symbol, method?: string): boolean;
     private getSource;
     getNesoiSymbol(name: string, path: string): ts.Symbol;
     getPropPath(node: ts.PropertyAssignment): string;
-    findAllNesoiBuilders(node: ts.Node): Partial<Record<BuilderType, Record<string, ts.Node>>>;
+    findAllNesoiBuilders(node: ts.Node): Partial<Record<ElementType, Record<string, ts.Node>>>;
     findAll(node: ts.Node, predicate: (node: ts.Node) => ts.Node[] | undefined): ts.Node[];
     private findParent;
     private findInCallChain;

package/lib/compiler/typescript/typescript_compiler.js

@@ -363,11 +363,11 @@ class TypeScriptCompiler {
         return this.checker.typeToString(fnReturnType, undefined, ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.NoTypeReduction | ts.TypeFormatFlags.UseFullyQualifiedType // TODO: this causes freaky imports
         );
     }
-    getFnText(node) {
+    getFnText(node, type) {
         // This method is only used to generated intermediate schemas
         // (the ones on the .nesoi folder). The function should have been
         // evaluated before generating this schema, so the typing is useless here
-        return `(${node.getFullText()}) as (...args: any[]) => any`;
+        return `(${node.getFullText()})${type ?? ' as (...args: any[]) => any'}`;
     }
     getFnType(node) {
         const type = this.checker.getTypeAtLocation(node);

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

@@ -1,7 +1,7 @@
 import { $Module, $Space } from "../../schema";
 import { $BlockOutput, $BlockType } from './block.schema';
 import { MessageTemplateDef } from "../entities/message/template/message_template.builder";
-import { $Dependency, BuilderNode } from "../../engine/dependency";
+import { BuilderNode, Dependency } from "../../engine/dependency";
 /**
  * @category Builders
  * @subcategory Block
@@ -11,9 +11,12 @@ export declare abstract class BlockBuilder<Space extends $Space, Module extends
     protected type: Type;
     protected name: string;
     protected _alias?: string;
-    protected _authn: string[];
+    protected _auth: {
+        provider: string;
+        resolver?: (user: any) => boolean;
+    }[];
     protected _inlineNodes: BuilderNode[];
-    protected _inputMsgs: $Dependency[];
+    protected _inputMsgs: Dependency[];
     protected _output?: $BlockOutput;
     constructor(module: string, type: Type, name: string);
     /** Block "human" name */
@@ -25,7 +28,7 @@ export declare abstract class BlockBuilder<Space extends $Space, Module extends
      * @returns The Builder, for call-chaining
      */
     protected message<Name extends string, Def extends MessageTemplateDef<Space, Module, Name>>(name: Name, def: Def): unknown;
-    authn(...providers: string[]): unknown;
+    auth<U extends keyof Space['authnUsers']>(provider: U, resolver?: (user: Space['authnUsers'][U]) => boolean): unknown;
     protected _input(...names: string[]): unknown;
     protected outputRaw(): unknown;
     protected outputMsg(...msgs: string[]): unknown;

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BlockBuilder = void 0;
 const message_builder_1 = require("../entities/message/message.builder");
 const dependency_1 = require("../../engine/dependency");
-const name_helpers_1 = require("../../compiler/helpers/name_helpers");
+const name_helpers_1 = require("../../engine/util/name_helpers");
 /**
  * @category Builders
  * @subcategory Block
@@ -13,7 +13,7 @@ class BlockBuilder {
         this.module = module;
         this.type = type;
         this.name = name;
-        this._authn = [];
+        this._auth = [];
         // References to all inline nodes, set during builder declaration (before build)
         this._inlineNodes = [];
         this._inputMsgs = [];
@@ -35,9 +35,7 @@ class BlockBuilder {
         const builder = new message_builder_1.MessageBuilder(this.module, msgName)
             .template(def);
         this._inlineNodes.push(new dependency_1.BuilderNode({
-            module: this.module,
-            type: 'message',
-            name: msgName,
+            tag: new dependency_1.Tag(this.module, 'message', msgName),
             builder,
             isInline: true,
             filepath: [], // This is added later by Treeshake.blockInlineNodes()
@@ -46,18 +44,25 @@ class BlockBuilder {
         return this;
     }
     // Authentication
-    authn(...providers) {
-        if (!Array.isArray(providers)) {
-            providers = [providers];
+    auth(provider, resolver) {
+        this._auth ?? (this._auth = []);
+        // Replace by provider name
+        const match = this._auth.findIndex(opt => opt.provider === provider);
+        if (match >= 0) {
+            this._auth.splice(match, 1);
         }
-        this._authn = providers;
+        this._auth.push({
+            provider: provider,
+            resolver
+        });
         return this;
     }
     // Input/Output
     _input(...names) {
         names.forEach((name) => {
             const fullName = name_helpers_1.NameHelpers.unabbrevName(name, this.name);
-            const dep = new dependency_1.$Dependency(this.module, 'message', fullName);
+            const tag = dependency_1.Tag.fromNameOrShort(this.module, 'message', fullName);
+            const dep = new dependency_1.Dependency(this.module, tag, { compile: true, runtime: true });
             this._inputMsgs.push(dep);
         });
         return this;
@@ -70,7 +75,9 @@ class BlockBuilder {
         this._output ?? (this._output = {});
         (_a = this._output).msg ?? (_a.msg = []);
         msgs.forEach(msg => {
-            this._output.msg.push(new dependency_1.$Dependency(this.module, 'message', msg, true));
+            const tag = dependency_1.Tag.fromNameOrShort(this.module, 'message', msg);
+            const dep = new dependency_1.Dependency(this.module, tag, { compile: true, runtime: true });
+            this._output.msg.push(dep.tag);
         });
         return this;
     }
@@ -79,8 +86,10 @@ class BlockBuilder {
         this._output ?? (this._output = {});
         (_a = this._output).obj ?? (_a.obj = []);
         objs.forEach(obj => {
+            const tag = dependency_1.Tag.fromNameOrShort(this.module, 'bucket', obj);
+            const dep = new dependency_1.Dependency(this.module, tag, { compile: true, runtime: true });
             this._output?.obj?.push({
-                dep: new dependency_1.$Dependency(this.module, 'bucket', obj, true),
+                tag: dep.tag,
                 many: false
             });
         });
@@ -91,8 +100,10 @@ class BlockBuilder {
         this._output ?? (this._output = {});
         (_a = this._output).obj ?? (_a.obj = []);
         objs.forEach(obj => {
+            const tag = dependency_1.Tag.fromNameOrShort(this.module, 'bucket', obj);
+            const dep = new dependency_1.Dependency(this.module, tag, { compile: true, runtime: true });
             this._output?.obj?.push({
-                dep: new dependency_1.$Dependency(this.module, 'bucket', obj, true),
+                tag: dep.tag,
                 many: true
             });
         });

package/lib/elements/blocks/block.js

@@ -20,7 +20,7 @@ class Block {
         if (typeof raw.$ !== 'string') {
             throw error_1.NesoiError.Message.InvalidType({ type: raw.$ });
         }
-        if (!this.schema.input.some(dep => dep.tag === `${this.module.name}::message:${raw.$}`)) {
+        if (!this.schema.input.some(tag => tag.module === this.module.name && tag.name === raw.$)) {
             throw error_1.NesoiError.Block.MessageNotSupported({ block: this.schema.name, message: raw.$ });
         }
         const msg = (await trx.message(raw));
@@ -28,7 +28,7 @@ class Block {
     }
     async consume(trx, msg, ctx) {
         log_1.Log.debug('trx', trx.globalId, `${(0, log_1.scopeTag)(this.type, this.schema.name)} Consume`, msg);
-        if (!this.schema.input.some(dep => dep.module === this.module.name && dep.name === msg.$)) {
+        if (!this.schema.input.some(tag => tag.module === this.module.name && tag.name === msg.$)) {
             throw error_1.NesoiError.Block.MessageNotSupported({ block: this.schema.name, message: msg.$ });
         }
         return this.run(trx, msg, ctx);

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

@@ -1,16 +1,19 @@
-import { TypeAsObj } from "../../compiler/elements/element";
+import { TypeAsObj } from "../../engine/util/type";
 import { $Message } from "../entities/message/message.schema";
-import { AnyUsers } from "../../engine/auth/authn";
-import { $Dependency } from "../../engine/dependency";
+import { Tag } from "../../engine/dependency";
 export type $BlockType = 'job' | 'resource' | 'machine' | 'queue' | 'topic';
 export type $BlockOutput = {
     raw?: TypeAsObj;
-    msg?: $Dependency[];
+    msg?: Tag[];
     obj?: {
-        dep: $Dependency;
+        tag: Tag;
         many: boolean;
     }[];
 };
+export type $BlockAuth = {
+    provider: string;
+    resolver?: (user: Record<string, any>) => boolean;
+};
 /**
  * @category Schemas
  * @subcategory Block
@@ -19,12 +22,12 @@ export declare class $Block {
     module: string;
     name: string;
     alias: string;
-    authn: string[];
-    input: $Dependency[];
+    auth: $BlockAuth[];
+    input: Tag[];
     output?: $BlockOutput | undefined;
     $t: $BlockType;
-    '#authn': AnyUsers;
+    '#authn': {};
     '#input': $Message;
     '#output': unknown;
-    constructor(module: string, name: string, alias: string, authn: string[], input: $Dependency[], output?: $BlockOutput | undefined);
+    constructor(module: string, name: string, alias: string, auth: $BlockAuth[], input: Tag[], output?: $BlockOutput | undefined);
 }

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

@@ -6,11 +6,11 @@ exports.$Block = void 0;
  * @subcategory Block
  */
 class $Block {
-    constructor(module, name, alias, authn, input, output) {
+    constructor(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.$t = 'block';

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

@@ -2,8 +2,9 @@ import { $Module, $Space } from "../../../../schema";
 import { $Job, $JobAssert, $JobMethod } from '../job.schema';
 import { TrxNode } from "../../../../engine/transaction/trx_node";
 import { BlockBuilder } from '../../block.builder';
-import { $Dependency, ResolvedBuilderNode } from "../../../../engine/dependency";
+import { Dependency, ResolvedBuilderNode, Tag } from "../../../../engine/dependency";
 import { Overlay } from "../../../../engine/util/type";
+import { $BlockAuth } from '../../block.schema';
 /**
  * @category Builders
  * @subcategory Block
@@ -12,14 +13,14 @@ export declare class MachineJobBuilder<Space extends $Space, Module extends $Mod
     protected module: string;
     protected name: Name;
     private alias;
-    protected _authn: string[];
-    protected _inputMsgs: $Dependency[];
+    protected _auth: $BlockAuth[];
+    protected _inputMsgs: Dependency[];
     $b: "job";
     $j: "MachineJob";
     private _extrasAndAsserts;
     private _method?;
     private machine;
-    constructor(module: string, name: Name, alias: string, _authn?: string[], _inputMsgs?: $Dependency[]);
+    constructor(module: string, name: Name, alias: string, _auth?: $BlockAuth[], _inputMsgs?: Dependency[]);
     /**
      * A function that will build new fields on the input message to be
      * consumed by the job.
@@ -45,7 +46,7 @@ export declare class MachineJobBuilder<Space extends $Space, Module extends $Mod
      */
     method<Trx = NoInfer<TrxNode<Space, Module, Job['#authn']>>, Msg = NoInfer<Job['#input']['#parsed']>, Extras = NoInfer<Job['#extra']>, C = NoInfer<Ctx>>(action: $JobMethod<Trx, Msg, any, Extras, C>): this;
     /** Build */
-    static build(node: MachineJobBuilderNode, input: $Dependency[]): $Job;
+    static build(node: MachineJobBuilderNode, input: Tag[]): $Job;
 }
 export type AnyMachineJobBuilder = MachineJobBuilder<any, any, any, any, any>;
 export type MachineJobDef<S extends $Space, M extends $Module, Name extends string, Job extends $Job, Ctx = {}> = ($: MachineJobBuilder<S, M, Name, Job, Ctx>) => void;

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

@@ -12,12 +12,12 @@ const error_1 = require("../../../../engine/data/error");
  * @subcategory Block
  */
 class MachineJobBuilder extends block_builder_1.BlockBuilder {
-    constructor(module, name, alias, _authn = [], _inputMsgs = []) {
+    constructor(module, name, alias, _auth = [], _inputMsgs = []) {
         super(module, 'job', name);
         this.module = module;
         this.name = name;
         this.alias = alias;
-        this._authn = _authn;
+        this._auth = _auth;
         this._inputMsgs = _inputMsgs;
         this.$b = 'job';
         this.$j = 'MachineJob';
@@ -67,7 +67,7 @@ class MachineJobBuilder extends block_builder_1.BlockBuilder {
         if (!node.builder._method) {
             throw error_1.NesoiError.Builder.Job.NoMethod({ job: node.builder.name });
         }
-        node.schema = new job_schema_1.$Job(node.builder.module, node.builder.name, node.builder.alias || node.builder.name, node.builder._authn, [...node.builder._inputMsgs, ...input], {}, node.builder._extrasAndAsserts, node.builder._method, {
+        node.schema = new job_schema_1.$Job(node.builder.module, node.builder.name, node.builder.alias || node.builder.name, node.builder._auth, [...node.builder._inputMsgs.map(m => m.tag), ...input], {}, node.builder._extrasAndAsserts, node.builder._method, {
             module: node.builder.module,
             machine: node.builder.machine
         });