nesoi 3.2.8 → 3.3.0

package/lib/engine/transaction/trx_engine.js

@@ -9,6 +9,7 @@ const memory_bucket_adapter_1 = require("../../elements/entities/bucket/adapters
 const elements_1 = require("../../elements");
 const bucket_model_schema_1 = require("../../elements/entities/bucket/model/bucket_model.schema");
 const bucket_graph_schema_1 = require("../../elements/entities/bucket/graph/bucket_graph.schema");
+const datetime_1 = require("../data/datetime");
 /**
  * @category Engine
  * @subcategory Transaction
@@ -74,10 +75,10 @@ class TrxEngine {
         }
         return trx;
     }
-    async trx(fn, authn) {
-        const trx = await this.get(undefined);
+    async trx(fn, id, auth) {
+        const trx = await this.get(id);
         try {
-            await this.authenticate(trx.root, authn);
+            await this.authenticate(trx.root, auth);
             let output;
             if (this.config?.wrap) {
                 output = await this.config?.wrap(trx, fn, this.services);
@@ -92,32 +93,80 @@ class TrxEngine {
         }
         return trx.status();
     }
+    async trx_hold(fn, id, authn) {
+        const trx = await this.get(id);
+        let output = {};
+        try {
+            await this.authenticate(trx.root, authn);
+            if (this.config?.wrap) {
+                output = await this.config?.wrap(trx, fn, this.services);
+            }
+            else {
+                output = await fn(trx.root);
+            }
+            await this.hold(trx, output);
+        }
+        catch (e) {
+            await this.rollback(trx, e);
+        }
+        return {
+            id: trx.id,
+            status: trx.status(),
+            commit: () => this.commit(trx, output),
+            rollback: (error) => this.rollback(trx, error)
+        };
+    }
+    /* Metadata sharing between modules */
+    getBucketMetadata(tag) {
+        return {
+            ...this.module.buckets[tag.name].getQueryMeta(),
+            tag,
+            meta: this.module.buckets[tag.name].adapter.config.meta,
+        };
+    }
+    getBucketDrive(tag) {
+        return this.module.buckets[tag.name].drive;
+    }
     // authentication
-    async authenticate(node, request = {}) {
+    async authenticate(node, request = {}, force = false) {
         if (!this.authnProviders) {
-            throw error_1.NesoiError.Authn.NoProvidersRegisteredForModule(this.module.name);
+            throw error_1.NesoiError.Auth.NoProvidersRegisteredForModule(this.module.name);
         }
         const users = {};
         const tokens = {};
         for (const providerName in this.authnProviders) {
             const provider = this.authnProviders[providerName];
-            const reqToken = request[providerName];
-            if (provider.eager || reqToken) {
-                if (!provider) {
-                    throw error_1.NesoiError.Authn.NoProviderRegisteredForModule(this.module.name, providerName);
-                }
-                const { user, token } = await provider.authenticate({ trx: node, token: reqToken });
-                users[providerName] = user;
+            if (!provider) {
+                throw error_1.NesoiError.Auth.NoProviderRegisteredForModule(this.module.name, providerName);
+            }
+            const token = request[providerName];
+            if (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);
     }
     //
+    async hold(trx, output) {
+        log_1.Log.info('module', this.module.name, `Hold ${(0, log_1.scopeTag)('trx', trx.id)} @ ${(0, log_1.anyScopeTag)(this.origin)}`);
+        trx_node_1.TrxNode.hold(trx.root, output);
+        await this.adapter.put(this.innerTrx.root, {
+            id: trx.id,
+            origin: this.origin,
+            start: trx.start,
+            end: trx.end,
+            module: this.module.name
+        });
+        return trx;
+    }
     async commit(trx, output) {
         log_1.Log.info('module', this.module.name, `Commit ${(0, log_1.scopeTag)('trx', trx.id)} @ ${(0, log_1.anyScopeTag)(this.origin)}`);
-        await trx_node_1.TrxNode.ok(trx.root, output);
-        trx_1.Trx.onFinish(trx);
+        trx_node_1.TrxNode.ok(trx.root, output);
+        trx.end = datetime_1.NesoiDatetime.now();
         await this.adapter.put(this.innerTrx.root, {
             id: trx.id,
             origin: this.origin,
@@ -125,13 +174,14 @@ class TrxEngine {
             end: trx.end,
             module: this.module.name
         });
+        await trx_1.Trx.onCommit(trx);
         return trx;
     }
     async rollback(trx, error) {
         log_1.Log.error('module', this.module.name, `[${error.status}] ${error.toString()}`, error.stack);
         log_1.Log.warn('module', this.module.name, `Rollback ${(0, log_1.scopeTag)('trx', trx.id)} @ ${(0, log_1.anyScopeTag)(this.origin)}`);
-        await trx_node_1.TrxNode.error(trx.root, error);
-        trx_1.Trx.onFinish(trx);
+        trx_node_1.TrxNode.error(trx.root, error);
+        trx.end = datetime_1.NesoiDatetime.now();
         await this.adapter.put(this.innerTrx.root, {
             id: trx.id,
             origin: this.origin,
@@ -139,6 +189,7 @@ class TrxEngine {
             end: trx.end,
             module: this.module.name
         });
+        await trx_1.Trx.onRollback(trx);
         return trx;
     }
 }

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

@@ -8,14 +8,16 @@ import { QueueTrxNode } from './nodes/queue.trx_node';
 import { ResourceTrxNode } from './nodes/resource.trx_node';
 import { $Message } from "../../elements/entities/message/message.schema";
 import { MachineTrxNode } from './nodes/machine.trx_node';
-import { AnyUsers, AuthnRequest } from '../auth/authn';
+import { AnyUsers, AuthRequest } from '../auth/authn';
 import { Enum } from "../../elements/entities/constants/constants";
 import { TopicTrxNode } from './nodes/topic.trx_node';
-type TrxNodeBlock = 'bucket' | 'message' | 'job' | 'resource' | 'machine' | 'queue' | 'topic' | 'controller';
+import { $BlockAuth } from "../../elements/blocks/block.schema";
+export type TrxNodeBlock = 'bucket' | 'message' | 'job' | 'resource' | 'machine' | 'queue' | 'topic' | 'controller' | 'externals';
+export type TrxNodeState = 'open' | 'hold' | 'ok' | 'error';
 export type TrxNodeStatus = {
     id: string;
     scope: 'root' | `${string}::${TrxNodeBlock}:${string}` | `${string}::virtual`;
-    state?: string;
+    state?: TrxNodeState;
     action?: string;
     input?: Record<string, any>;
     output?: Record<string, any>;
@@ -27,12 +29,13 @@ export type TrxNodeStatus = {
  * @category Engine
  * @subcategory Transaction
  */
-export declare class TrxNode<Space extends $Space, M extends $Module, Authn extends AnyUsers> {
+export declare class TrxNode<Space extends $Space, M extends $Module, AuthUsers extends AnyUsers> {
     private scope;
     private trx;
     private parent;
     private module;
-    private authn?;
+    private auth?;
+    private external?;
     id: string;
     globalId: string;
     private children;
@@ -42,15 +45,16 @@ export declare class TrxNode<Space extends $Space, M extends $Module, Authn exte
     private output?;
     private error?;
     private time;
-    constructor(scope: 'root' | `${string}::${TrxNodeBlock}:${string}` | `${string}::virtual`, trx: AnyTrx, parent: AnyTrxNode | undefined, module: AnyModule, authn?: {
-        tokens: AuthnRequest<any>;
-        users: Authn;
-    } | undefined, id?: string);
-    static open(node: AnyTrxNode, action: string, input: Record<string, any>): Promise<void>;
-    static ok(node: AnyTrxNode, output?: Record<string, any>): Promise<void>;
-    static error(node: AnyTrxNode, error: any): Promise<any>;
+    constructor(scope: 'root' | `${string}::${TrxNodeBlock}:${string}` | `${string}::virtual`, trx: AnyTrx, parent: AnyTrxNode | undefined, module: AnyModule, auth?: {
+        tokens: AuthRequest<any>;
+        users: AuthUsers;
+    } | undefined, external?: boolean | undefined, id?: string);
+    static open(node: AnyTrxNode, action: string, input: Record<string, any>): void;
+    static hold(node: AnyTrxNode, output?: Record<string, any>): void;
+    static ok(node: AnyTrxNode, output?: Record<string, any>): void;
+    static error(node: AnyTrxNode, error: any): any;
     message<Raw extends M['#input']['#raw'], Msg extends $Message = M['messages'][Raw['$'] & keyof M['messages']]>(raw: Raw): Promise<M['#input']['#parsed']>;
-    value<K extends keyof M['constants']['values']>(key: K): M["constants"]["values"][K]["value"];
+    value<K extends keyof M['constants']['values']>(name: K): M['constants']['values'][K]['value'];
     enum<EnumName extends keyof M['constants']['enums']>(name: EnumName): Enum<M['constants']['enums'][EnumName]>;
     bucket<Name extends keyof M['buckets'], Bucket extends M['buckets'][Name]>(name: Name): BucketTrxNode<M, Bucket>;
     job<Name extends keyof M['jobs'], Job extends M['jobs'][Name]>(name: Name): JobTrxNode<M, Job>;
@@ -59,20 +63,20 @@ export declare class TrxNode<Space extends $Space, M extends $Module, Authn exte
     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: AuthnRequest<keyof Authn>): Promise<TrxNode<$Space, $Module, Authn>>;
-    token<U extends keyof Authn & keyof M['#authn']>(provider: U): string;
-    user<U extends keyof Authn & keyof M['#authn']>(provider: U): M['#authn'][U];
+    authenticate(authnRequest: 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>;
     status(): TrxNodeStatus;
-    static makeChildNode<Space extends $Space, M extends $Module, Authn extends AnyUsers>(node: TrxNode<Space, M, Authn>, module: string, block: TrxNodeBlock, name: string): TrxNode<Space, M, Authn>;
-    static makeVirtualChildNode<Space extends $Space, M extends $Module, Authn extends AnyUsers>(node: TrxNode<Space, M, Authn>, module: AnyModule): TrxNode<Space, M, Authn>;
-    static addAuthn(node: AnyTrxNode, tokens: AuthnRequest<any>, users: AnyUsers): void;
+    static merge<Space extends $Space, M extends $Module, AuthUsers extends AnyUsers>(to: TrxNode<Space, M, AuthUsers>, from: TrxNode<Space, M, AuthUsers>): void;
+    static makeChildNode<Space extends $Space, M extends $Module, AuthUsers extends AnyUsers>(node: TrxNode<Space, M, AuthUsers>, module: string, block: TrxNodeBlock, name: string): TrxNode<Space, M, AuthUsers>;
+    static makeVirtualChildNode<Space extends $Space, M extends $Module, AuthUsers extends AnyUsers>(node: TrxNode<Space, M, AuthUsers>, module: AnyModule): TrxNode<Space, M, AuthUsers>;
+    static addAuthn(node: AnyTrxNode, tokens: AuthRequest<any>, users: AnyUsers): void;
     static getModule(node: AnyTrxNode): AnyModule;
     static getFirstUserMatch(node: AnyTrxNode, authnProviders?: Record<string, any>): {
         provider: string;
         user: any;
     } | undefined;
-    static checkAuthn(node: AnyTrxNode, authnProviderOptions?: string[]): void;
+    static checkAuth(node: AnyTrxNode, options?: $BlockAuth[]): Promise<void>;
 }
 export type AnyTrxNode = TrxNode<any, any, any>;
-export {};

package/lib/engine/transaction/trx_node.js

@@ -13,6 +13,8 @@ const constants_1 = require("../../elements/entities/constants/constants");
 const i18n_1 = require("../util/i18n");
 const datetime_1 = require("../data/datetime");
 const topic_trx_node_1 = require("./nodes/topic.trx_node");
+const dependency_1 = require("../dependency");
+const log_1 = require("../util/log");
 /*
     Transaction Node
 */
@@ -21,15 +23,17 @@ const topic_trx_node_1 = require("./nodes/topic.trx_node");
  * @subcategory Transaction
  */
 class TrxNode {
-    constructor(scope, trx, parent, module, authn, id) {
+    constructor(scope, trx, parent, module, auth, external, id) {
         this.scope = scope;
         this.trx = trx;
         this.parent = parent;
         this.module = module;
-        this.authn = authn;
+        this.auth = auth;
+        this.external = external;
         this.children = [];
         this.time = {
             start: datetime_1.NesoiDatetime.now(),
+            hold: undefined,
             end: undefined
         };
         if (parent) {
@@ -40,17 +44,22 @@ class TrxNode {
         }
         this.globalId = `${this.trx.id}.${this.id}`;
     }
-    static async open(node, action, input) {
+    static open(node, action, input) {
         node.state = 'open';
         node.action = action;
         node.input = input;
     }
-    static async ok(node, output) {
+    static hold(node, output) {
+        node.state = 'ok';
+        node.output = output;
+        node.time.hold = datetime_1.NesoiDatetime.now();
+    }
+    static ok(node, output) {
         node.state = 'ok';
         node.output = output;
         node.time.end = datetime_1.NesoiDatetime.now();
     }
-    static async error(node, error) {
+    static error(node, error) {
         node.state = 'error';
         if (error instanceof error_1.NesoiError.BaseError) {
             error.message = i18n_1.i18n.error(error, node.trx.root.module.daemon);
@@ -67,56 +76,59 @@ class TrxNode {
     // Entities
     async message(raw) {
         const node = TrxNode.makeChildNode(this, this.module.name, 'message', raw.$);
-        await TrxNode.open(node, 'parse', raw);
+        TrxNode.open(node, 'parse', raw);
         try {
             const parsed = await message_parser_1.MessageParser.parseWithTrxModule(node, raw);
-            await TrxNode.ok(node);
+            TrxNode.ok(node);
             return parsed;
         }
         catch (e) {
-            await TrxNode.error(node, e);
+            TrxNode.error(node, e);
             throw e;
         }
     }
-    value(key) {
+    value(name) {
+        const tag = dependency_1.Tag.fromNameOrShort(this.module.name, 'constants.value', name);
+        // (External values have been injected during build as static externals)
+        const key = tag.module !== this.module.name
+            ? tag.short
+            : tag.name;
         return this.module.schema.constants.values[key].value;
     }
     enum(name) {
-        const schema = this.module.schema.constants.enums[name];
+        const tag = dependency_1.Tag.fromNameOrShort(this.module.name, 'constants.value', name);
+        // (External enums have been injected during build as static externals)
+        const key = tag.module !== this.module.name
+            ? tag.short
+            : tag.name;
+        const schema = this.module.schema.constants.enums[key];
         if (!schema) {
-            throw error_1.NesoiError.Module.EnumNotFound(this.module, name);
+            throw error_1.NesoiError.Module.EnumNotFound(this.module, key);
         }
-        return new constants_1.Enum(this.module.schema.constants.enums[name]);
+        return new constants_1.Enum(this.module.schema.constants.enums[key]);
     }
     // Blocks
     bucket(name) {
-        return new bucket_trx_node_1.BucketTrxNode(this, this.module.buckets[name]);
+        const tag = dependency_1.Tag.fromNameOrShort(this.module.name, 'bucket', name);
+        return new bucket_trx_node_1.BucketTrxNode(this, tag);
     }
     job(name) {
-        const job = this.module.jobs[name];
-        if (!job) {
-            throw error_1.NesoiError.Module.JobNotIncluded(this.module, name);
-        }
-        return new job_trx_node_1.JobTrxNode(this, job);
+        const tag = dependency_1.Tag.fromNameOrShort(this.module.name, 'job', name);
+        return new job_trx_node_1.JobTrxNode(this, tag);
     }
     // Method for internal use, which allows running a job with a custom context.
     // This is used by composite blocks to pass things such as an object
     // or the previous/next machine states along with the message.
     static jobWithCustomCtx(node, name, ctx) {
-        const job = node.module.jobs[name];
-        if (!job) {
-            throw error_1.NesoiError.Module.JobNotIncluded(node.module, name);
-        }
-        return new job_trx_node_1.JobTrxNode(node, job, ctx);
+        const tag = dependency_1.Tag.fromNameOrShort(node.module.name, 'job', name);
+        return new job_trx_node_1.JobTrxNode(node, tag, ctx);
     }
     resource(name) {
-        const resource = this.module.resources[name];
-        if (!resource) {
-            throw error_1.NesoiError.Module.ResourceNotIncluded(this.module, name);
-        }
-        return new resource_trx_node_1.ResourceTrxNode(this, resource);
+        const tag = dependency_1.Tag.fromNameOrShort(this.module.name, 'resource', name);
+        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);
@@ -124,6 +136,7 @@ class TrxNode {
         return new machine_trx_node_1.MachineTrxNode(this, machine);
     }
     queue(name) {
+        // TODO: support external
         const queue = this.module.queues[name];
         if (!queue) {
             throw error_1.NesoiError.Module.QueueNotIncluded(this.module, name);
@@ -131,6 +144,7 @@ class TrxNode {
         return new queue_trx_node_1.QueueTrxNode(this, queue);
     }
     topic(name) {
+        // TODO: support external
         const topic = this.module.topics[name];
         if (!topic) {
             throw error_1.NesoiError.Module.TopicNotIncluded(this.module, name);
@@ -139,21 +153,16 @@ class TrxNode {
     }
     // Authentication
     async authenticate(authnRequest) {
-        const newNode = new TrxNode(this.scope, this.trx, this, this.module, this.authn);
+        const newNode = new TrxNode(this.scope, this.trx, this, this.module, this.auth);
         await this.trx.engine.authenticate(newNode, authnRequest);
         return newNode;
     }
-    token(provider) {
-        if (!this.authn?.tokens) {
-            throw error_1.NesoiError.Authn.NoUsersAuthenticatedForTrxNode(this.globalId);
-        }
-        return this.authn?.tokens[provider];
+    async token(provider) {
+        return this.auth?.tokens[provider];
     }
-    user(provider) {
-        if (!this.authn?.users) {
-            throw error_1.NesoiError.Authn.NoUsersAuthenticatedForTrxNode(this.globalId);
-        }
-        return this.authn?.users[provider];
+    async user(provider) {
+        await TrxNode.checkAuth(this, [{ provider: provider }]);
+        return this.auth?.users[provider];
     }
     // Virtual Module Transaction
     async virtual(def, fn) {
@@ -164,14 +173,14 @@ class TrxNode {
         const virtualModule = await module_1.Module.virtual(this.module.daemon, def);
         // Create trx node of virtual module
         const node = TrxNode.makeVirtualChildNode(this, virtualModule);
-        await TrxNode.open(node, 'run', {});
+        TrxNode.open(node, 'run', {});
         try {
             const result = await fn(node);
-            await TrxNode.ok(node);
+            TrxNode.ok(node);
             return result;
         }
         catch (e) {
-            await TrxNode.error(node, e);
+            TrxNode.error(node, e);
             throw e;
         }
     }
@@ -190,28 +199,34 @@ class TrxNode {
         };
     }
     //
+    static merge(to, from) {
+        for (const child of from.children) {
+            to.children.push(child);
+            to.trx.addNode(child);
+        }
+    }
     static makeChildNode(node, module, block, name) {
-        const child = new TrxNode(`${module}::${block}:${name}`, node.trx, node, node.module, node.authn);
+        const child = new TrxNode(`${module}::${block}:${name}`, node.trx, node, node.module, node.auth);
         node.children.push(child);
         node.trx.addNode(child);
         return child;
     }
     static makeVirtualChildNode(node, module) {
-        const child = new TrxNode(`${module.name}::virtual`, node.trx, node, module, node.authn);
+        const child = new TrxNode(`${module.name}::virtual`, node.trx, node, module, node.auth);
         node.children.push(child);
         node.trx.addNode(child);
         return child;
     }
     static addAuthn(node, tokens, users) {
         var _a, _b;
-        node.authn ?? (node.authn = {
+        node.auth ?? (node.auth = {
             tokens: {},
             users: {}
         });
-        (_a = node.authn).tokens ?? (_a.tokens = {});
-        (_b = node.authn).users ?? (_b.users = {});
-        Object.assign(node.authn.tokens, tokens);
-        Object.assign(node.authn.users, users);
+        (_a = node.auth).tokens ?? (_a.tokens = {});
+        (_b = node.auth).users ?? (_b.users = {});
+        Object.assign(node.auth.tokens, tokens);
+        Object.assign(node.auth.users, users);
     }
     static getModule(node) {
         return node.module;
@@ -220,24 +235,51 @@ class TrxNode {
         if (!authnProviders)
             return undefined;
         for (const provider in authnProviders) {
-            const user = node.authn?.users[provider];
+            const user = node.auth?.users[provider];
             if (user) {
                 return { provider, user };
             }
         }
         return undefined;
     }
-    static checkAuthn(node, authnProviderOptions) {
-        if (!authnProviderOptions?.length)
+    static async checkAuth(node, options) {
+        if (!options?.length)
             return;
-        if (node.authn?.users) {
-            for (const provider of authnProviderOptions) {
-                if (provider in node.authn.users) {
-                    return;
+        if (!node.auth?.users) {
+            throw error_1.NesoiError.Trx.Unauthorized({ providers: options.map(opt => opt.provider) });
+        }
+        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.resolver && !opt.resolver(user)) {
+                    log_1.Log.debug('trx', node.globalId, `User from provider '${opt.provider}' didn't pass the authorization resolver`);
+                    continue;
+                }
+                log_1.Log.debug('trx', node.globalId, `User from provider '${opt.provider}' pre-authenticated${opt.resolver ? ' and authorized' : ''}`);
+                return;
+            }
+            // Non-eager providers
+            else if (opt.provider in node.auth.tokens) {
+                try {
+                    await node.trx.engine.authenticate(node, {
+                        [opt.provider]: node.auth.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];
+                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;
                 }
+                log_1.Log.debug('trx', node.globalId, `User from provider '${opt.provider}' authenticated${opt.resolver ? ' and authorized' : ''}`);
+                return;
             }
         }
-        throw error_1.NesoiError.Trx.NotAuthenticated({});
+        throw error_1.NesoiError.Trx.Unauthorized({ providers: options.map(opt => opt.provider) });
     }
 }
 exports.TrxNode = TrxNode;

package/lib/engine/tree.d.ts

@@ -1,9 +1,8 @@
-import { BuilderType } from "../schema";
 import { ResolvedBuilderNode } from './dependency';
 import { AnyModule } from './module';
-import { TreeshakeConfig } from "../compiler/treeshake";
-import { ProgressiveBuildCache } from "../compiler/progressive";
+import { TreeshakeConfig } from './treeshake';
 type TraverseCallback = (node: ResolvedBuilderNode) => Promise<void>;
+import { ProgressiveBuildCache } from "../compiler/progressive";
 /**
  * A tree of module elements which allows building in the correct order.
  *
@@ -33,11 +32,11 @@ export declare class ModuleTree {
      */
     private treeshake;
     /**
-     * Each element declares it's dependencies as a `$Dependency`.
+     * Each element declares it's dependencies as a list of `Dependency`.
      * In order to assemble the build layers, it's necessary to
      * resolve them into a graph of `ResolvedBuilderNode`s.
      * This also resolves the inline nodes, to allow merging the schemas
-     * of inline nodes on build.
+     * of inline nodes on compile.
      *
      * @param nodesByModule A dictionary of builder nodes by module name
      * @returns A dictionary of resolved builder nodes
@@ -66,17 +65,6 @@ export declare class ModuleTree {
      * @param fn Callback to be run for each node
      */
     traverse(actionAlias: string, fn: TraverseCallback): Promise<void>;
-    /**
-     * Get schema of a dependency-like object.
-     *
-     * @param node A dependency-like object
-     * @return An element schema
-     */
-    getSchema(node: {
-        module: string;
-        type: BuilderType;
-        name: string;
-    }): import("../elements").$Message | import("../elements").$Machine | import("../elements").$Bucket | import("../elements").$Constants | import("../elements").$Job | import("../elements").$Externals | import("../elements").$Resource | import("../elements").$Controller;
     /**
      * Return a list of all nodes of all modules on the tree.
      *