nesoi 3.2.8 → 3.3.0

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

@@ -2,47 +2,67 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JobTrxNode = 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 JobTrxNode {
-    constructor(trx, job, ctx) {
+    constructor(trx, tag, ctx) {
         this.trx = trx;
-        this.job = job;
+        this.tag = tag;
         this.ctx = ctx;
-    }
-    async run(message) {
-        const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.job.schema.module, 'job', this.job.schema.name);
-        await trx_node_1.TrxNode.open(trx, 'run', message);
-        // Special case for Jobs with a '' inline message,
-        // which is not required on the run method.
-        if (!('$' in message)
-            && this.job.schema.input.some(dep => dep.tag === `${this.job.module.name}::message:${this.job.schema.name}`)) {
-            message['$'] = this.job.schema.name;
+        const module = trx_node_1.TrxNode.getModule(trx);
+        this.external = tag.module !== module.name;
+        if (!this.external) {
+            this.job = dependency_1.Tag.element(tag, trx);
+            if (!this.job) {
+                throw error_1.NesoiError.Trx.NodeNotFound(this.tag.full, trx.globalId);
+            }
         }
-        let response;
-        try {
-            response = await this.job.consumeRaw(trx, message, this.ctx);
+    }
+    /*
+        Wrap
+    */
+    async wrap(action, input, fn, fmtTrxOut) {
+        const wrapped = async (parentTrx, job) => {
+            const trx = trx_node_1.TrxNode.makeChildNode(parentTrx, job.schema.module, 'job', job.schema.name);
+            trx_node_1.TrxNode.open(trx, action, input);
+            let out;
+            try {
+                out = await fn(trx, job);
+            }
+            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 await trx_node_1.TrxNode.error(trx, e);
+        else {
+            return wrapped(this.trx, this.job);
         }
-        await trx_node_1.TrxNode.ok(trx, response);
-        return response;
+    }
+    async run(message) {
+        return this.wrap('run', message, (trx, job) => {
+            // Special case for Jobs with a '' inline message,
+            // which is not required on the run method.
+            if (!('$' in message)
+                && job.schema.input.some(tag => tag.full === `${job.module.name}::message:${job.schema.name}`)) {
+                message['$'] = job.schema.name;
+            }
+            return job.consumeRaw(trx, message, this.ctx);
+        });
     }
     async forward(message) {
-        const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.job.schema.module, 'job', this.job.schema.name);
-        await trx_node_1.TrxNode.open(trx, 'forward', message);
-        let response;
-        try {
-            response = await this.job.consume(trx, message, this.ctx);
-        }
-        catch (e) {
-            throw await trx_node_1.TrxNode.error(trx, e);
-        }
-        await trx_node_1.TrxNode.ok(trx, response);
-        return response;
+        return this.wrap('forward', message, (trx, job) => {
+            return job.consume(trx, message);
+        });
     }
 }
 exports.JobTrxNode = JobTrxNode;

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

@@ -13,28 +13,28 @@ class MachineTrxNode {
     }
     async run(message) {
         const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.machine.schema.module, 'machine', this.machine.schema.name);
-        await trx_node_1.TrxNode.open(trx, 'run', message);
+        trx_node_1.TrxNode.open(trx, 'run', message);
         let response;
         try {
             response = await this.machine.consumeRaw(trx, message);
         }
         catch (e) {
-            throw await trx_node_1.TrxNode.error(trx, e);
+            throw trx_node_1.TrxNode.error(trx, e);
         }
-        await trx_node_1.TrxNode.ok(trx, response);
+        trx_node_1.TrxNode.ok(trx, response);
         return response;
     }
     async forward(message) {
         const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.machine.schema.module, 'machine', this.machine.schema.name);
-        await trx_node_1.TrxNode.open(trx, 'forward', message);
+        trx_node_1.TrxNode.open(trx, 'forward', message);
         let response;
         try {
             response = await this.machine.consume(trx, message);
         }
         catch (e) {
-            throw await trx_node_1.TrxNode.error(trx, e);
+            throw trx_node_1.TrxNode.error(trx, e);
         }
-        await trx_node_1.TrxNode.ok(trx, response);
+        trx_node_1.TrxNode.ok(trx, response);
         return response;
     }
 }

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

@@ -13,15 +13,15 @@ class QueueTrxNode {
     }
     async push(raw) {
         const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.queue.schema.module, 'queue', this.queue.schema.name);
-        await trx_node_1.TrxNode.open(trx, 'push', { raw });
+        trx_node_1.TrxNode.open(trx, 'push', { raw });
         let response;
         try {
             // response = this.queue.push(trx, raw);
         }
         catch (e) {
-            throw await trx_node_1.TrxNode.error(trx, e);
+            throw trx_node_1.TrxNode.error(trx, e);
         }
-        await trx_node_1.TrxNode.ok(trx, response);
+        trx_node_1.TrxNode.ok(trx, response);
     }
 }
 exports.QueueTrxNode = QueueTrxNode;

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

@@ -1,8 +1,9 @@
 import { $Module } from "../../../schema";
-import { TrxNode } from '../trx_node';
+import { AnyTrxNode, TrxNode } from '../trx_node';
 import { Message } from "../../../elements/entities/message/message";
 import { $Resource } from "../../../elements/blocks/resource/resource.schema";
 import { Resource } from "../../../elements/blocks/resource/resource";
+import { Tag } from "../../dependency";
 type ViewRaw<$ extends $Resource> = $['#input.view']['#raw'];
 type QueryRaw<$ extends $Resource> = $['#input.query']['#raw'];
 type CreateRaw<$ extends $Resource> = $['#input.create']['#raw'];
@@ -14,8 +15,11 @@ type DeleteRaw<$ extends $Resource> = $['#input.delete']['#raw'];
  */
 export declare class ResourceTrxNode<M extends $Module, $ extends $Resource> {
     private trx;
-    private resource;
-    constructor(trx: TrxNode<any, M, any>, resource: Resource<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: Resource<any, M, $>) => Promise<any>, fmtTrxOut?: (out: any) => any): Promise<any>;
     forward(message: Message<$['#input']>): Promise<$['#output']>;
     run(raw: ViewRaw<$> | QueryRaw<$> | CreateRaw<$> | UpdateRaw<$> | DeleteRaw<$>): Promise<$['#output']>;
     view<View extends keyof $['#bucket']['views'], Raw extends Omit<ViewRaw<$>, '$'>>(raw: Raw): Promise<$['#bucket']['views'][View]['#data']>;
@@ -23,6 +27,5 @@ export declare class ResourceTrxNode<M extends $Module, $ extends $Resource> {
     create(raw: Omit<CreateRaw<$>, '$'>): Promise<$['#bucket']['#data']>;
     update(raw: Omit<UpdateRaw<$>, '$'>): Promise<$['#bucket']['#data']>;
     delete(raw: Omit<DeleteRaw<$>, '$'>): Promise<void>;
-    private consumeRaw;
 }
 export {};

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

@@ -2,78 +2,95 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResourceTrxNode = 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 ResourceTrxNode {
-    constructor(trx, resource) {
+    constructor(trx, tag) {
         this.trx = trx;
-        this.resource = resource;
+        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 forward(message) {
-        const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.resource.schema.module, 'resource', this.resource.schema.name);
-        await trx_node_1.TrxNode.open(trx, 'forward', message);
-        let response;
-        try {
-            response = await this.resource.consume(trx, message);
+    /*
+        Wrap
+    */
+    async wrap(action, input, fn, fmtTrxOut) {
+        const wrapped = async (parentTrx, resource) => {
+            const trx = trx_node_1.TrxNode.makeChildNode(parentTrx, resource.schema.module, 'resource', 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 await trx_node_1.TrxNode.error(trx, e);
+        else {
+            return wrapped(this.trx, this.resource);
         }
-        await trx_node_1.TrxNode.ok(trx, response);
-        return response;
+    }
+    async forward(message) {
+        return this.wrap('forward', message, (trx, resource) => {
+            return resource.consume(trx, message);
+        });
     }
     async run(raw) {
-        const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.resource.schema.module, 'resource', this.resource.schema.name);
-        await trx_node_1.TrxNode.open(trx, 'run', raw);
-        return this.consumeRaw(trx, raw);
+        return this.wrap('run', raw, (trx, resource) => {
+            return resource.consumeRaw(trx, raw);
+        });
     }
     async view(raw) {
-        const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.resource.schema.module, 'resource', this.resource.schema.name);
-        await trx_node_1.TrxNode.open(trx, 'view', raw);
-        const inRaw = Object.assign({}, raw);
-        inRaw.$ = `${this.resource.schema.name}.view`;
-        return this.consumeRaw(trx, inRaw);
+        return this.wrap('view', raw, (trx, resource) => {
+            const inRaw = Object.assign({}, raw);
+            inRaw.$ = `${resource.schema.name}.view`;
+            return resource.consumeRaw(trx, inRaw);
+        });
     }
     async query(raw) {
-        const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.resource.schema.module, 'resource', this.resource.schema.name);
-        await trx_node_1.TrxNode.open(trx, 'query', raw);
-        const inRaw = Object.assign({}, raw);
-        inRaw.$ = `${this.resource.schema.name}.query`;
-        return this.consumeRaw(trx, inRaw);
+        return this.wrap('query', raw, (trx, resource) => {
+            const inRaw = Object.assign({}, raw);
+            inRaw.$ = `${resource.schema.name}.query`;
+            return resource.consumeRaw(trx, inRaw);
+        });
     }
     async create(raw) {
-        const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.resource.schema.module, 'resource', this.resource.schema.name);
-        await trx_node_1.TrxNode.open(trx, 'create', raw);
-        const inRaw = Object.assign({}, raw);
-        inRaw.$ = `${this.resource.schema.name}.create`;
-        return this.consumeRaw(trx, inRaw);
+        return this.wrap('create', raw, (trx, resource) => {
+            const inRaw = Object.assign({}, raw);
+            inRaw.$ = `${resource.schema.name}.create`;
+            return resource.consumeRaw(trx, inRaw);
+        });
     }
     async update(raw) {
-        const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.resource.schema.module, 'resource', this.resource.schema.name);
-        await trx_node_1.TrxNode.open(trx, 'update', raw);
-        const inRaw = Object.assign({}, raw);
-        inRaw.$ = `${this.resource.schema.name}.update`;
-        return this.consumeRaw(trx, inRaw);
+        return this.wrap('update', raw, (trx, resource) => {
+            const inRaw = Object.assign({}, raw);
+            inRaw.$ = `${resource.schema.name}.update`;
+            return resource.consumeRaw(trx, inRaw);
+        });
     }
     async delete(raw) {
-        const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.resource.schema.module, 'resource', this.resource.schema.name);
-        await trx_node_1.TrxNode.open(trx, 'delete', raw);
-        const inRaw = Object.assign({}, raw);
-        inRaw.$ = `${this.resource.schema.name}.delete`;
-        await this.consumeRaw(trx, inRaw);
-    }
-    async consumeRaw(trx, message) {
-        let response;
-        try {
-            response = await this.resource.consumeRaw(trx, message);
-        }
-        catch (e) {
-            throw await trx_node_1.TrxNode.error(trx, e);
-        }
-        await trx_node_1.TrxNode.ok(trx, response);
-        return response;
+        return this.wrap('delete', raw, (trx, resource) => {
+            const inRaw = Object.assign({}, raw);
+            inRaw.$ = `${resource.schema.name}.delete`;
+            return resource.consumeRaw(trx, inRaw);
+        });
     }
 }
 exports.ResourceTrxNode = ResourceTrxNode;

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

@@ -13,38 +13,38 @@ class TopicTrxNode {
     }
     async subscribe(fn) {
         const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.topic.schema.module, 'topic', this.topic.schema.name);
-        await trx_node_1.TrxNode.open(trx, 'subscribe', {});
+        trx_node_1.TrxNode.open(trx, 'subscribe', {});
         let id;
         try {
             id = await this.topic.subscribe(this.trx, fn);
         }
         catch (e) {
-            throw await trx_node_1.TrxNode.error(trx, e);
+            throw trx_node_1.TrxNode.error(trx, e);
         }
-        await trx_node_1.TrxNode.ok(trx, { id });
+        trx_node_1.TrxNode.ok(trx, { id });
         return id;
     }
     async unsubscribe(id) {
         const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.topic.schema.module, 'topic', this.topic.schema.name);
-        await trx_node_1.TrxNode.open(trx, 'unsubscribe', {});
+        trx_node_1.TrxNode.open(trx, 'unsubscribe', {});
         try {
             await this.topic.unsubscribe(this.trx, id);
         }
         catch (e) {
-            throw await trx_node_1.TrxNode.error(trx, e);
+            throw trx_node_1.TrxNode.error(trx, e);
         }
-        await trx_node_1.TrxNode.ok(trx, undefined);
+        trx_node_1.TrxNode.ok(trx, undefined);
     }
     async publish(raw) {
         const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.topic.schema.module, 'topic', this.topic.schema.name);
-        await trx_node_1.TrxNode.open(trx, 'publish', { raw });
+        trx_node_1.TrxNode.open(trx, 'publish', { raw });
         try {
             await this.topic.consumeRaw(trx, raw);
         }
         catch (e) {
-            throw await trx_node_1.TrxNode.error(trx, e);
+            throw trx_node_1.TrxNode.error(trx, e);
         }
-        await trx_node_1.TrxNode.ok(trx, undefined);
+        trx_node_1.TrxNode.ok(trx, undefined);
     }
 }
 exports.TopicTrxNode = TopicTrxNode;

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

@@ -1,12 +1,12 @@
 import { $Module, $Space } from "../../schema";
 import { Module } from '../module';
 import { AnyTrxNode, TrxNode, TrxNodeStatus } from './trx_node';
-import { AnyTrxEngine, TrxEngineOrigin } from './trx_engine';
-import { AnyUsers, AuthnRequest } from '../auth/authn';
+import { AnyTrxEngine, HeldTrxNode as TrxNodeHold, TrxEngineOrigin } from './trx_engine';
+import { AnyUsers, AuthRequest } from '../auth/authn';
 import { NesoiDatetime } from '../data/datetime';
 import { NesoiError } from '../data/error';
 type TrxOrigin = TrxEngineOrigin | `trx:${string}`;
-type TrxState = 'open' | 'ok' | 'error';
+type TrxState = 'open' | 'hold' | 'ok' | 'error';
 /**
  * @category Engine
  * @subcategory Transaction
@@ -27,21 +27,23 @@ export declare class TrxStatus<Output> {
  * @category Engine
  * @subcategory Transaction
  */
-export declare class Trx<S extends $Space, M extends $Module, Authn extends AnyUsers> {
+export declare class Trx<S extends $Space, M extends $Module, AuthUsers extends AnyUsers> {
     engine: AnyTrxEngine;
     private module;
     id: string;
     private origin;
-    root: TrxNode<S, M, Authn>;
-    nodes: Record<string, TrxNode<S, M, Authn>>;
+    root: TrxNode<S, M, AuthUsers>;
+    nodes: Record<string, TrxNode<S, M, AuthUsers>>;
+    holds: Record<string, TrxNodeHold<any>>;
     start: NesoiDatetime;
     end?: NesoiDatetime;
     ctx: Record<string, any>;
-    constructor(engine: AnyTrxEngine, module: Module<S, M>, origin: TrxOrigin, authn?: {
-        tokens: AuthnRequest<any>;
-        users: Authn;
-    }, id?: string, root?: TrxNode<S, M, Authn>, nodes?: Record<string, TrxNode<S, M, Authn>>);
-    addNode(node: TrxNode<S, M, Authn>): void;
+    constructor(engine: AnyTrxEngine, module: Module<S, M>, origin: TrxOrigin, auth?: {
+        tokens: AuthRequest<any>;
+        users: AuthUsers;
+    }, id?: string, root?: TrxNode<S, M, AuthUsers>, nodes?: Record<string, TrxNode<S, M, AuthUsers>>);
+    addNode(node: TrxNode<S, M, AuthUsers>): void;
+    holdNode(node: TrxNodeHold<any>): void;
     status(): TrxStatus<any>;
     /**
      * Context Manipulation
@@ -57,7 +59,8 @@ export declare class Trx<S extends $Space, M extends $Module, Authn extends AnyU
      * to the transaction. Elements should not modify the transaction.
      */
     static set(node: AnyTrxNode, key: string, value: any): AnyTrx;
-    static onFinish(trx: AnyTrx): void;
+    static onCommit(trx: AnyTrx): Promise<void>;
+    static onRollback(trx: AnyTrx): Promise<void>;
 }
 export type AnyTrx = Trx<any, any, any>;
 export {};

package/lib/engine/transaction/trx.js

@@ -26,6 +26,7 @@ class TrxStatus {
     summary() {
         const state = this.state ? (0, string_1.colored)(`[${this.state}]`, {
             'open': 'lightblue',
+            'hold': 'yellow',
             'ok': 'lightgreen',
             'error': 'lightred'
         }[this.state]) : 'unknown';
@@ -36,6 +37,7 @@ class TrxStatus {
             nodes.forEach(node => {
                 const state = node.state ? (0, string_1.colored)(`[${node.state}]`, {
                     'open': 'lightblue',
+                    'hold': 'yellow',
                     'ok': 'lightgreen',
                     'error': 'lightred'
                 }[node.state] || 'lightred') : 'unknown';
@@ -54,20 +56,25 @@ exports.TrxStatus = TrxStatus;
  * @subcategory Transaction
  */
 class Trx {
-    constructor(engine, module, origin, authn, id, root, nodes) {
+    constructor(engine, module, origin, auth, id, root, nodes) {
         this.engine = engine;
+        this.holds = {};
         this.start = datetime_1.NesoiDatetime.now();
         this.ctx = {};
         this.module = module;
         this.id = id || (Math.random() + 1).toString(36).substring(7);
         this.origin = origin;
-        this.root = root || new trx_node_1.TrxNode('root', this, undefined, module, authn, id);
+        this.root = root || new trx_node_1.TrxNode('root', this, undefined, module, auth, false, id);
         this.nodes = nodes || {};
     }
     addNode(node) {
         const nodeId = node.id;
         this.nodes[nodeId] = node;
     }
+    holdNode(node) {
+        const nodeId = node.id;
+        this.holds[nodeId] = node;
+    }
     status() {
         const state = this.root.state;
         const output = this.root.output;
@@ -96,8 +103,17 @@ class Trx {
         return trx;
     }
     //
-    static onFinish(trx) {
+    static async onCommit(trx) {
+        for (const h in trx.holds) {
+            await trx.holds[h].commit();
+        }
+    }
+    static async onRollback(trx) {
         trx.end = datetime_1.NesoiDatetime.now();
+        for (const h in trx.holds) {
+            const error = `rollback ${trx.id}`;
+            await trx.holds[h].rollback(error);
+        }
     }
 }
 exports.Trx = Trx;

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

@@ -2,13 +2,13 @@ import { $Module, $Space } from "../../elements";
 import { BucketAdapter } from "../../elements/entities/bucket/adapters/bucket_adapter";
 import { Trx } from './trx';
 import { AnyUsers } from '../auth/authn';
-import { TrxNode, TrxNodeStatus } from './trx_node';
+import { TrxNode } from './trx_node';
 import { TrxData } from './trx_engine';
-export type TrxEngineWrapFn<S extends $Space, M extends $Module> = (trx: TrxNode<S, M, any>) => Promise<TrxNodeStatus>;
-export type TrxEngineConfig<S extends $Space, M extends $Module, Authn extends AnyUsers, Services extends Record<string, any>> = {
+export type TrxEngineWrapFn<S extends $Space, M extends $Module> = (trx: TrxNode<S, M, any>) => Promise<any>;
+export type TrxEngineConfig<S extends $Space, M extends $Module, AuthUsers extends AnyUsers, Services extends Record<string, any>> = {
     /**
      * Adapter used to store transactions of this module.
      */
     adapter?: (schema: M) => BucketAdapter<TrxData>;
-    wrap?: <T extends Trx<S, M, Authn>>(trx: T, fn: TrxEngineWrapFn<S, M>, services: Services) => Promise<any>;
+    wrap?: <T extends Trx<S, M, AuthUsers>>(trx: T, fn: TrxEngineWrapFn<S, M>, services: Services) => Promise<any>;
 };

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

@@ -1,10 +1,14 @@
 import { $Module, $Space } from "../../schema";
 import { Module } from '../module';
-import { AnyTrx, Trx } from './trx';
+import { AnyTrx, Trx, TrxStatus } from './trx';
 import { TrxNode, TrxNodeStatus } from './trx_node';
-import { AnyAuthnProviders, AuthnRequest } from '../auth/authn';
+import { AnyAuthnProviders, AuthRequest } from '../auth/authn';
+import { BucketAdapterConfig } from "../../elements/entities/bucket/adapters/bucket_adapter";
 import { TrxEngineConfig } from './trx_engine.config';
-import { IService } from '../apps/service';
+import { IService } from '../app/service';
+import { Tag } from '../dependency';
+import { AnyBucket } from "../../elements/entities/bucket/bucket";
+import { DriveAdapter } from "../../elements/entities/drive/drive_adapter";
 export type TrxEngineOrigin = `app:${string}` | `plugin:${string}`;
 export type TrxData = {
     id: AnyTrx['id'];
@@ -13,11 +17,21 @@ export type TrxData = {
     start: AnyTrx['start'];
     end: AnyTrx['end'];
 };
+export type HeldTrxNode<Output> = {
+    id: string;
+    status: TrxStatus<Output>;
+    commit: () => Promise<AnyTrx>;
+    rollback: (error: string) => Promise<AnyTrx>;
+};
+export type BucketMetadata = ReturnType<AnyBucket['getQueryMeta']> & {
+    tag: Tag;
+    meta: BucketAdapterConfig['meta'];
+};
 /**
  * @category Engine
  * @subcategory Transaction
  */
-export declare class TrxEngine<S extends $Space, M extends $Module, Authn extends AnyAuthnProviders> {
+export declare class TrxEngine<S extends $Space, M extends $Module, AuthUsers extends AnyAuthnProviders> {
     private origin;
     private module;
     private authnProviders?;
@@ -29,11 +43,15 @@ export declare class TrxEngine<S extends $Space, M extends $Module, Authn extend
      */
     private innerTrx;
     private adapter;
-    constructor(origin: TrxEngineOrigin, module: Module<S, M>, authnProviders?: Authn | undefined, config?: TrxEngineConfig<S, M, any, any> | undefined, services?: Record<string, IService>);
+    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>, authn?: AuthnRequest<keyof Authn>): Promise<import("./trx").TrxStatus<any>>;
-    authenticate(node: TrxNode<S, M, any>, request?: AuthnRequest<keyof Authn>): Promise<void>;
+    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>>;
+    getBucketMetadata(tag: Tag): BucketMetadata;
+    getBucketDrive(tag: Tag): DriveAdapter | undefined;
+    authenticate(node: TrxNode<S, M, any>, request?: AuthRequest<keyof AuthUsers>, force?: boolean): Promise<void>;
+    private hold;
     private commit;
     private rollback;
 }