nesoi 3.3.2 → 3.3.4

package/lib/engine/transaction/nodes/machine.trx_node.d.ts

@@ -1,16 +1,20 @@
 import { $Module } from "../../../schema";
-import { TrxNode } from '../trx_node';
+import { AnyTrxNode, TrxNode } from '../trx_node';
 import { $Machine } from "../../../elements/blocks/machine/machine.schema";
 import { Machine, MachineOutput } from "../../../elements/blocks/machine/machine";
 import { Message } from "../../../elements/entities/message/message";
+import { Tag } from "../../dependency";
 /**
  * @category Engine
  * @subcategory Transaction
  */
 export declare class MachineTrxNode<M extends $Module, $ extends $Machine> {
     private trx;
-    private machine;
-    constructor(trx: TrxNode<any, M, any>, machine: Machine<any, M, $>);
+    private tag;
+    private external;
+    private machine?;
+    constructor(trx: TrxNode<any, M, any>, tag: Tag);
+    wrap(action: string, input: Record<string, any>, fn: (trx: AnyTrxNode, element: Machine<any, M, $>) => Promise<any>, fmtTrxOut?: (out: any) => any): Promise<any>;
     run(message: $['#input']['#raw']): Promise<MachineOutput>;
     forward(message: Message<$['#input']>): Promise<MachineOutput>;
 }

package/lib/engine/transaction/nodes/machine.trx_node.js

@@ -2,40 +2,60 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MachineTrxNode = void 0;
 const trx_node_1 = require("../trx_node");
+const dependency_1 = require("../../dependency");
+const error_1 = require("../../data/error");
+const external_trx_node_1 = require("./external.trx_node");
 /**
  * @category Engine
  * @subcategory Transaction
  */
 class MachineTrxNode {
-    constructor(trx, machine) {
+    constructor(trx, tag) {
         this.trx = trx;
-        this.machine = machine;
+        this.tag = tag;
+        const module = trx_node_1.TrxNode.getModule(trx);
+        this.external = tag.module !== module.name;
+        if (!this.external) {
+            this.machine = dependency_1.Tag.element(tag, trx);
+            if (!this.machine) {
+                throw error_1.NesoiError.Trx.NodeNotFound(this.tag.full, trx.globalId);
+            }
+        }
     }
-    async run(message) {
-        const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.machine.schema.module, 'machine', this.machine.schema.name);
-        trx_node_1.TrxNode.open(trx, 'run', message);
-        let response;
-        try {
-            response = await this.machine.consumeRaw(trx, message);
+    /*
+        Wrap
+    */
+    async wrap(action, input, fn, fmtTrxOut) {
+        const wrapped = async (parentTrx, machine) => {
+            const trx = trx_node_1.TrxNode.makeChildNode(parentTrx, machine.schema.module, 'machine', machine.schema.name);
+            trx_node_1.TrxNode.open(trx, action, input);
+            let out;
+            try {
+                out = await fn(trx, machine);
+            }
+            catch (e) {
+                throw trx_node_1.TrxNode.error(trx, e);
+            }
+            trx_node_1.TrxNode.ok(trx, fmtTrxOut ? fmtTrxOut(out) : out);
+            return out;
+        };
+        if (this.external) {
+            const ext = new external_trx_node_1.ExternalTrxNode(this.trx, this.tag);
+            return ext.run(trx => dependency_1.Tag.element(this.tag, trx), wrapped);
         }
-        catch (e) {
-            throw trx_node_1.TrxNode.error(trx, e);
+        else {
+            return wrapped(this.trx, this.machine);
         }
-        trx_node_1.TrxNode.ok(trx, response);
-        return response;
+    }
+    async run(message) {
+        return this.wrap('run', message, (trx, machine) => {
+            return machine.consumeRaw(trx, message);
+        });
     }
     async forward(message) {
-        const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.machine.schema.module, 'machine', this.machine.schema.name);
-        trx_node_1.TrxNode.open(trx, 'forward', message);
-        let response;
-        try {
-            response = await this.machine.consume(trx, message);
-        }
-        catch (e) {
-            throw trx_node_1.TrxNode.error(trx, e);
-        }
-        trx_node_1.TrxNode.ok(trx, response);
-        return response;
+        return this.wrap('forward', message, (trx, machine) => {
+            return machine.consume(trx, message);
+        });
     }
 }
 exports.MachineTrxNode = MachineTrxNode;

package/lib/engine/transaction/nodes/queue.trx_node.d.ts

@@ -1,6 +1,7 @@
 import { $Module, RawMessageInput } from "../../../schema";
-import { TrxNode } from '../trx_node';
+import { AnyTrxNode, TrxNode } from '../trx_node';
 import { $Queue } from "../../../elements/blocks/queue/queue.schema";
+import { Tag } from "../../dependency";
 import { Queue } from "../../../elements/blocks/queue/queue";
 /**
  * @category Engine
@@ -8,7 +9,10 @@ import { Queue } from "../../../elements/blocks/queue/queue";
  */
 export declare class QueueTrxNode<M extends $Module, $ extends $Queue> {
     private trx;
-    private queue;
-    constructor(trx: TrxNode<any, M, any>, queue: Queue<M, $>);
+    private tag;
+    private external;
+    private queue?;
+    constructor(trx: TrxNode<any, M, any>, tag: Tag);
+    wrap(action: string, input: Record<string, any>, fn: (trx: AnyTrxNode, element: Queue<M, $>) => Promise<any>, fmtTrxOut?: (out: any) => any): Promise<any>;
     push(raw: RawMessageInput<M, keyof M['messages']>): Promise<void>;
 }

package/lib/engine/transaction/nodes/queue.trx_node.js

@@ -2,26 +2,55 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueueTrxNode = void 0;
 const trx_node_1 = require("../trx_node");
+const external_trx_node_1 = require("./external.trx_node");
+const dependency_1 = require("../../dependency");
+const error_1 = require("../../data/error");
 /**
  * @category Engine
  * @subcategory Transaction
  */
 class QueueTrxNode {
-    constructor(trx, queue) {
+    constructor(trx, tag) {
         this.trx = trx;
-        this.queue = queue;
+        this.tag = tag;
+        const module = trx_node_1.TrxNode.getModule(trx);
+        this.external = tag.module !== module.name;
+        if (!this.external) {
+            this.queue = dependency_1.Tag.element(tag, trx);
+            if (!this.queue) {
+                throw error_1.NesoiError.Trx.NodeNotFound(this.tag.full, trx.globalId);
+            }
+        }
     }
-    async push(raw) {
-        const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.queue.schema.module, 'queue', this.queue.schema.name);
-        trx_node_1.TrxNode.open(trx, 'push', { raw });
-        let response;
-        try {
-            // response = this.queue.push(trx, raw);
+    /*
+        Wrap
+    */
+    async wrap(action, input, fn, fmtTrxOut) {
+        const wrapped = async (parentTrx, queue) => {
+            const trx = trx_node_1.TrxNode.makeChildNode(parentTrx, queue.schema.module, 'queue', queue.schema.name);
+            trx_node_1.TrxNode.open(trx, action, input);
+            let out;
+            try {
+                out = await fn(trx, queue);
+            }
+            catch (e) {
+                throw trx_node_1.TrxNode.error(trx, e);
+            }
+            trx_node_1.TrxNode.ok(trx, fmtTrxOut ? fmtTrxOut(out) : out);
+            return out;
+        };
+        if (this.external) {
+            const ext = new external_trx_node_1.ExternalTrxNode(this.trx, this.tag);
+            return ext.run(trx => dependency_1.Tag.element(this.tag, trx), wrapped);
         }
-        catch (e) {
-            throw trx_node_1.TrxNode.error(trx, e);
+        else {
+            return wrapped(this.trx, this.queue);
         }
-        trx_node_1.TrxNode.ok(trx, response);
+    }
+    async push(raw) {
+        // return this.wrap('push', raw, (trx, queue) => {
+        //     return queue.push(trx, message)
+        // })
     }
 }
 exports.QueueTrxNode = QueueTrxNode;

package/lib/engine/transaction/nodes/topic.trx_node.d.ts

@@ -1,16 +1,20 @@
 import { $Module } from "../../../schema";
-import { TrxNode } from '../trx_node';
+import { AnyTrxNode, TrxNode } from '../trx_node';
 import { $Topic } from "../../../elements/blocks/topic/topic.schema";
 import { Topic } from "../../../elements/blocks/topic/topic";
 import { AnyMessage } from "../../../elements/entities/message/message";
+import { Tag } from "../../dependency";
 /**
  * @category Engine
  * @subcategory Transaction
  */
 export declare class TopicTrxNode<M extends $Module, $ extends $Topic> {
     private trx;
-    private topic;
-    constructor(trx: TrxNode<any, M, any>, topic: Topic<any, M, $>);
+    private tag;
+    private external;
+    private resource?;
+    constructor(trx: TrxNode<any, M, any>, tag: Tag);
+    wrap(action: string, input: Record<string, any>, fn: (trx: AnyTrxNode, element: Topic<any, M, $>) => Promise<any>, fmtTrxOut?: (out: any) => any): Promise<any>;
     subscribe(fn: (msg: AnyMessage) => void): Promise<string>;
     unsubscribe(id: string): Promise<void>;
     publish(raw: $['#input']['#raw']): Promise<void>;

package/lib/engine/transaction/nodes/topic.trx_node.js

@@ -2,49 +2,65 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TopicTrxNode = void 0;
 const trx_node_1 = require("../trx_node");
+const dependency_1 = require("../../dependency");
+const error_1 = require("../../data/error");
+const external_trx_node_1 = require("./external.trx_node");
 /**
  * @category Engine
  * @subcategory Transaction
  */
 class TopicTrxNode {
-    constructor(trx, topic) {
+    constructor(trx, tag) {
         this.trx = trx;
-        this.topic = topic;
+        this.tag = tag;
+        const module = trx_node_1.TrxNode.getModule(trx);
+        this.external = tag.module !== module.name;
+        if (!this.external) {
+            this.resource = dependency_1.Tag.element(tag, trx);
+            if (!this.resource) {
+                throw error_1.NesoiError.Trx.NodeNotFound(this.tag.full, trx.globalId);
+            }
+        }
     }
-    async subscribe(fn) {
-        const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.topic.schema.module, 'topic', this.topic.schema.name);
-        trx_node_1.TrxNode.open(trx, 'subscribe', {});
-        let id;
-        try {
-            id = await this.topic.subscribe(this.trx, fn);
+    /*
+        Wrap
+    */
+    async wrap(action, input, fn, fmtTrxOut) {
+        const wrapped = async (parentTrx, resource) => {
+            const trx = trx_node_1.TrxNode.makeChildNode(parentTrx, resource.schema.module, 'topic', resource.schema.name);
+            trx_node_1.TrxNode.open(trx, action, input);
+            let out;
+            try {
+                out = await fn(trx, resource);
+            }
+            catch (e) {
+                throw trx_node_1.TrxNode.error(trx, e);
+            }
+            trx_node_1.TrxNode.ok(trx, fmtTrxOut ? fmtTrxOut(out) : out);
+            return out;
+        };
+        if (this.external) {
+            const ext = new external_trx_node_1.ExternalTrxNode(this.trx, this.tag);
+            return ext.run(trx => dependency_1.Tag.element(this.tag, trx), wrapped);
         }
-        catch (e) {
-            throw trx_node_1.TrxNode.error(trx, e);
+        else {
+            return wrapped(this.trx, this.resource);
         }
-        trx_node_1.TrxNode.ok(trx, { id });
-        return id;
+    }
+    async subscribe(fn) {
+        return this.wrap('subscribe', {}, (trx, topic) => {
+            return topic.subscribe(trx, fn);
+        });
     }
     async unsubscribe(id) {
-        const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.topic.schema.module, 'topic', this.topic.schema.name);
-        trx_node_1.TrxNode.open(trx, 'unsubscribe', {});
-        try {
-            await this.topic.unsubscribe(this.trx, id);
-        }
-        catch (e) {
-            throw trx_node_1.TrxNode.error(trx, e);
-        }
-        trx_node_1.TrxNode.ok(trx, undefined);
+        return this.wrap('unsubscribe', { id }, (trx, topic) => {
+            return topic.unsubscribe(trx, id);
+        });
     }
     async publish(raw) {
-        const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.topic.schema.module, 'topic', this.topic.schema.name);
-        trx_node_1.TrxNode.open(trx, 'publish', { raw });
-        try {
-            await this.topic.consumeRaw(trx, raw);
-        }
-        catch (e) {
-            throw trx_node_1.TrxNode.error(trx, e);
-        }
-        trx_node_1.TrxNode.ok(trx, undefined);
+        return this.wrap('publish', { raw }, (trx, topic) => {
+            return topic.consumeRaw(trx, raw);
+        });
     }
 }
 exports.TopicTrxNode = TopicTrxNode;

package/lib/engine/transaction/trx_engine.d.ts

@@ -2,7 +2,7 @@ import { $Module, $Space } from "../../schema";
 import { Module } from '../module';
 import { AnyTrx, Trx, TrxStatus } from './trx';
 import { TrxNode, TrxNodeStatus } from './trx_node';
-import { AnyAuthnProviders, AuthRequest } from '../auth/authn';
+import { AnyAuthnProviders, AnyUsers, AuthRequest } from '../auth/authn';
 import { BucketAdapterConfig } from "../../elements/entities/bucket/adapters/bucket_adapter";
 import { TrxEngineConfig } from './trx_engine.config';
 import { IService } from '../app/service';
@@ -46,11 +46,11 @@ export declare class TrxEngine<S extends $Space, M extends $Module, AuthUsers ex
     constructor(origin: TrxEngineOrigin, module: Module<S, M>, authnProviders?: AuthUsers | undefined, config?: TrxEngineConfig<S, M, any, any> | undefined, services?: Record<string, IService>);
     getModule(): Module<S, M>;
     get(id?: string): Promise<Trx<S, M, any>>;
-    trx(fn: (trx: TrxNode<S, M, any>) => Promise<TrxNodeStatus>, id?: string, auth?: AuthRequest<keyof AuthUsers>): Promise<TrxStatus<any>>;
-    trx_hold(fn: (trx: TrxNode<S, M, any>) => Promise<any>, id?: string, authn?: AuthRequest<keyof AuthUsers>): Promise<HeldTrxNode<any>>;
+    trx(fn: (trx: TrxNode<S, M, any>) => Promise<TrxNodeStatus>, id?: string, tokens?: AuthRequest<keyof AuthUsers>, users?: Partial<AuthUsers>): Promise<TrxStatus<any>>;
+    trx_hold(fn: (trx: TrxNode<S, M, any>) => Promise<any>, id?: string, authn?: AuthRequest<keyof AuthUsers>, users?: Partial<AuthUsers>): Promise<HeldTrxNode<any>>;
     getBucketMetadata(tag: Tag): BucketMetadata;
     getBucketDrive(tag: Tag): DriveAdapter | undefined;
-    authenticate(node: TrxNode<S, M, any>, request?: AuthRequest<keyof AuthUsers>, force?: boolean): Promise<void>;
+    authenticate(node: TrxNode<S, M, any>, tokens?: AuthRequest<keyof AuthUsers>, users?: AnyUsers, force?: boolean): Promise<void>;
     private hold;
     private commit;
     private rollback;

package/lib/engine/transaction/trx_engine.js

@@ -75,10 +75,10 @@ class TrxEngine {
         }
         return trx;
     }
-    async trx(fn, id, auth) {
+    async trx(fn, id, tokens, users) {
         const trx = await this.get(id);
         try {
-            await this.authenticate(trx.root, auth);
+            await this.authenticate(trx.root, tokens, users);
             let output;
             if (this.config?.wrap) {
                 output = await this.config?.wrap(trx, fn, this.services);
@@ -93,11 +93,11 @@ class TrxEngine {
         }
         return trx.status();
     }
-    async trx_hold(fn, id, authn) {
+    async trx_hold(fn, id, authn, users) {
         const trx = await this.get(id);
         let output = {};
         try {
-            await this.authenticate(trx.root, authn);
+            await this.authenticate(trx.root, authn, users);
             if (this.config?.wrap) {
                 output = await this.config?.wrap(trx, fn, this.services);
             }
@@ -128,27 +128,27 @@ class TrxEngine {
         return this.module.buckets[tag.name].drive;
     }
     // authentication
-    async authenticate(node, request = {}, force = false) {
+    async authenticate(node, tokens = {}, users = {}, force = false) {
         if (!this.authnProviders) {
             throw error_1.NesoiError.Auth.NoProvidersRegisteredForModule(this.module.name);
         }
-        const users = {};
-        const tokens = {};
+        const _users = { ...users };
+        const _tokens = {};
         for (const providerName in this.authnProviders) {
             const provider = this.authnProviders[providerName];
             if (!provider) {
                 throw error_1.NesoiError.Auth.NoProviderRegisteredForModule(this.module.name, providerName);
             }
-            const token = request[providerName];
+            const token = tokens[providerName];
             if (token) {
-                tokens[providerName] = token;
+                _tokens[providerName] = token;
                 if (provider.eager || force) {
                     const { user } = await provider.authenticate({ trx: node, token });
                     users[providerName] = user;
                 }
             }
         }
-        trx_node_1.TrxNode.addAuthn(node, tokens, users);
+        trx_node_1.TrxNode.addAuthn(node, _tokens, _users);
     }
     //
     async hold(trx, output) {

package/lib/engine/transaction/trx_node.d.ts

@@ -63,7 +63,7 @@ export declare class TrxNode<Space extends $Space, M extends $Module, AuthUsers
     machine<Name extends keyof M['machines'], Machine extends M['machines'][Name]>(name: Name): MachineTrxNode<M, Machine>;
     queue<Name extends keyof M['queues'], Queue extends M['queues'][Name]>(name: Name): QueueTrxNode<M, Queue>;
     topic<Name extends keyof M['topics'], topic extends M['topics'][Name]>(name: Name): TopicTrxNode<M, topic>;
-    authenticate(authnRequest: AuthRequest<keyof AuthUsers>): Promise<TrxNode<$Space, $Module, AuthUsers>>;
+    authenticate(tokens: AuthRequest<keyof AuthUsers>): Promise<TrxNode<$Space, $Module, AuthUsers>>;
     token<U extends keyof AuthUsers & keyof M['#authn']>(provider: U): Promise<string>;
     user<U extends keyof AuthUsers & keyof M['#authn']>(provider: U): Promise<M['#authn'][U]>;
     virtual<T>(def: VirtualModuleDef, fn: ($: AnyTrxNode) => T | Promise<T>): Promise<T>;

package/lib/engine/transaction/trx_node.js

@@ -128,33 +128,21 @@ class TrxNode {
         return new resource_trx_node_1.ResourceTrxNode(this, tag);
     }
     machine(name) {
-        // TODO: support external
-        const machine = this.module.machines[name];
-        if (!machine) {
-            throw error_1.NesoiError.Module.MachineNotIncluded(this.module, name);
-        }
-        return new machine_trx_node_1.MachineTrxNode(this, machine);
+        const tag = dependency_1.Tag.fromNameOrShort(this.module.name, 'machine', name);
+        return new machine_trx_node_1.MachineTrxNode(this, tag);
     }
     queue(name) {
-        // TODO: support external
-        const queue = this.module.queues[name];
-        if (!queue) {
-            throw error_1.NesoiError.Module.QueueNotIncluded(this.module, name);
-        }
-        return new queue_trx_node_1.QueueTrxNode(this, queue);
+        const tag = dependency_1.Tag.fromNameOrShort(this.module.name, 'queue', name);
+        return new queue_trx_node_1.QueueTrxNode(this, tag);
     }
     topic(name) {
-        // TODO: support external
-        const topic = this.module.topics[name];
-        if (!topic) {
-            throw error_1.NesoiError.Module.TopicNotIncluded(this.module, name);
-        }
-        return new topic_trx_node_1.TopicTrxNode(this, topic);
+        const tag = dependency_1.Tag.fromNameOrShort(this.module.name, 'topic', name);
+        return new topic_trx_node_1.TopicTrxNode(this, tag);
     }
     // Authentication
-    async authenticate(authnRequest) {
+    async authenticate(tokens) {
         const newNode = new TrxNode(this.scope, this.trx, this, this.module, this.auth);
-        await this.trx.engine.authenticate(newNode, authnRequest);
+        await this.trx.engine.authenticate(newNode, tokens);
         return newNode;
     }
     async token(provider) {
@@ -219,6 +207,10 @@ class TrxNode {
     }
     static addAuthn(node, tokens, users) {
         var _a, _b;
+        log_1.Log.trace('trx', node.globalId, 'Transaction authenticated', {
+            tokens,
+            users
+        });
         node.auth ?? (node.auth = {
             tokens: {},
             users: {}
@@ -245,13 +237,15 @@ class TrxNode {
     static async checkAuth(node, options) {
         if (!options?.length)
             return;
-        if (!node.auth?.users) {
+        if (!Object.keys(node.auth?.tokens || {}).length) {
             throw error_1.NesoiError.Trx.Unauthorized({ providers: options.map(opt => opt.provider) });
         }
+        const users = node.auth?.users || {};
+        const tokens = node.auth?.tokens || {};
         for (const opt of options) {
             // Eager provider or previously authenticated user
-            if (opt.provider in node.auth.users) {
-                const user = node.auth.users[opt.provider];
+            if (opt.provider in users) {
+                const user = users[opt.provider];
                 if (opt.resolver && !opt.resolver(user)) {
                     log_1.Log.debug('trx', node.globalId, `User from provider '${opt.provider}' didn't pass the authorization resolver`);
                     continue;
@@ -260,17 +254,17 @@ class TrxNode {
                 return;
             }
             // Non-eager providers
-            else if (opt.provider in node.auth.tokens) {
+            else if (opt.provider in tokens) {
                 try {
                     await node.trx.engine.authenticate(node, {
-                        [opt.provider]: node.auth.tokens[opt.provider]
-                    }, true);
+                        [opt.provider]: tokens[opt.provider]
+                    }, {}, true);
                 }
                 catch {
                     log_1.Log.debug('trx', node.globalId, `Attempt to authenticate with provider '${opt.provider}' failed`);
                     continue;
                 }
-                const user = node.auth.users[opt.provider];
+                const user = users[opt.provider];
                 if (opt.resolver && !opt.resolver(user)) {
                     log_1.Log.debug('trx', node.globalId, `User from provider '${opt.provider}' didn't pass the authorization resolver`);
                     continue;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "nesoi",
-    "version": "3.3.2",
+    "version": "3.3.4",
     "description": "Declarative framework for data-driven applications",
     "repository": {
         "type": "git",