nesoi 3.0.0

package/lib/engine/transaction/trx_node.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrxNode = void 0;
+const error_1 = require("../data/error");
+const module_1 = require("../module");
+const bucket_trx_node_1 = require("./nodes/bucket.trx_node");
+const job_trx_node_1 = require("./nodes/job.trx_node");
+const queue_trx_node_1 = require("./nodes/queue.trx_node");
+const resource_trx_node_1 = require("./nodes/resource.trx_node");
+const message_parser_1 = require("../../elements/entities/message/message_parser");
+const machine_trx_node_1 = require("./nodes/machine.trx_node");
+const constants_1 = require("../../elements/entities/constants/constants");
+const i18n_1 = require("../util/i18n");
+const datetime_1 = require("../data/datetime");
+/*
+    Transaction Node
+*/
+class TrxNode {
+    constructor(scope, trx, parent, module, users, id) {
+        this.scope = scope;
+        this.trx = trx;
+        this.parent = parent;
+        this.module = module;
+        this.users = users;
+        this.children = [];
+        this.time = {
+            start: datetime_1.NesoiDatetime.now(),
+            end: undefined
+        };
+        if (parent) {
+            this.id = id || (Math.random() + 1).toString(36).substring(7);
+        }
+        else {
+            this.id = '#';
+        }
+        this.globalId = `${this.trx.id}.${this.id}`;
+    }
+    static async open(node, action, input) {
+        node.state = 'open';
+        node.action = action;
+        node.input = input;
+    }
+    static async ok(node, output) {
+        node.state = 'ok';
+        node.output = output;
+        node.time.end = datetime_1.NesoiDatetime.now();
+    }
+    static async error(node, error) {
+        node.state = 'error';
+        node.error = i18n_1.i18n.error(error, node.trx.root.module.daemon);
+        node.time.end = datetime_1.NesoiDatetime.now();
+    }
+    // Entities
+    async message(raw) {
+        const node = TrxNode.makeChildNode(this, this.module.name, 'message', raw.$);
+        await TrxNode.open(node, 'parse', raw);
+        try {
+            const parsed = await message_parser_1.MessageParser.parseWithTrxModule(node, raw);
+            await TrxNode.ok(node);
+            return parsed;
+        }
+        catch (e) {
+            await TrxNode.error(node, e);
+            throw e;
+        }
+    }
+    value(key) {
+        return this.module.schema.constants.values[key].value;
+    }
+    enum(name) {
+        const schema = this.module.schema.constants.enums[name];
+        if (!schema) {
+            throw error_1.NesoiError.Module.EnumNotFound(this.module, name);
+        }
+        return new constants_1.Enum(this.module.schema.constants.enums[name]);
+    }
+    // Blocks
+    bucket(name) {
+        return new bucket_trx_node_1.BucketTrxNode(this, this.module.buckets[name]);
+    }
+    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);
+    }
+    // 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);
+    }
+    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);
+    }
+    machine(name) {
+        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);
+    }
+    queue(name) {
+        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);
+    }
+    // Authentication
+    user(provider) {
+        if (!this.users) {
+            throw error_1.NesoiError.Authn.NoUsersAuthenticatedForTrxNode(this.globalId);
+        }
+        return this.users[provider];
+    }
+    // Virtual Module Transaction
+    async virtual(def, fn) {
+        // Build virtual module
+        const module = TrxNode.getModule(this);
+        const virtualModule = await module_1.Module.virtual(module, def);
+        // Create trx node of virtual module
+        const node = TrxNode.makeVirtualChildNode(this, virtualModule);
+        await TrxNode.open(node, 'run', {});
+        try {
+            const result = await fn(node);
+            await TrxNode.ok(node);
+            return result;
+        }
+        catch (e) {
+            await TrxNode.error(node, e);
+            throw e;
+        }
+    }
+    // Status
+    status() {
+        return {
+            id: this.id,
+            scope: this.scope,
+            state: this.state,
+            action: this.action,
+            input: this.input,
+            output: this.output,
+            error: this.error,
+            nodes: this.children.map(child => child.status()),
+            app: this.time.end ? (this.time.end.epoch - this.time.start.epoch) : -1
+        };
+    }
+    //
+    static makeChildNode(node, module, block, name) {
+        const child = new TrxNode(`${module}::${block}:${name}`, node.trx, node, node.module);
+        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.children.push(child);
+        node.trx.addNode(child);
+        return child;
+    }
+    static getModule(node) {
+        return node.module;
+    }
+}
+exports.TrxNode = TrxNode;

package/lib/engine/tree.d.ts

@@ -0,0 +1,34 @@
+import { BuilderType } from "../schema";
+import { ResolvedBuilderNode } from './dependency';
+import { AnyModule } from './module';
+import { TreeshakeConfig } from "../compiler/treeshake";
+type TraverseCallback = (node: ResolvedBuilderNode) => Promise<void>;
+export declare class ModuleTree {
+    modules: Record<string, AnyModule>;
+    config?: TreeshakeConfig | undefined;
+    private layers;
+    constructor(modules: Record<string, AnyModule>, config?: TreeshakeConfig | undefined);
+    resolve(): Promise<void>;
+    private treeshake;
+    /**
+     * Each node declares it's dependencies as a `$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.
+     */
+    private resolveDependencies;
+    private getAllInlineNodes;
+    /**
+     * In order to build nodes on the proper order, a set of layers must be stablished
+     */
+    private resolveLayers;
+    traverse(actionAlias: string, fn: TraverseCallback): Promise<void>;
+    getSchema(node: {
+        module: string;
+        type: BuilderType;
+        name: string;
+    }): import("../elements").$Message | import("../elements").$Bucket | import("../elements").$Constants | import("../elements").$Externals | import("../elements").$Job | import("../elements").$Resource | import("../elements").$Machine | import("../elements").$Controller;
+    allNodes(): ResolvedBuilderNode[];
+}
+export {};

package/lib/engine/tree.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleTree = void 0;
+const error_1 = require("../compiler/error");
+const log_1 = require("./util/log");
+const string_1 = require("./util/string");
+const treeshake_1 = require("../compiler/treeshake");
+class ModuleTree {
+    constructor(modules, config) {
+        this.modules = modules;
+        this.config = config;
+        this.layers = [];
+    }
+    async resolve() {
+        const nodesByModule = await this.treeshake();
+        const resolvedNodes = await this.resolveDependencies(nodesByModule);
+        this.layers = this.resolveLayers(resolvedNodes);
+    }
+    async treeshake() {
+        log_1.Log.debug('compiler', 'tree', 'Treeshaking');
+        const nodesByModule = {};
+        for (const m in this.modules) {
+            const module = this.modules[m];
+            const nodes = await treeshake_1.Treeshake.module(module, this.config);
+            nodesByModule[module.name] = nodes;
+        }
+        return nodesByModule;
+    }
+    /**
+     * Each node declares it's dependencies as a `$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.
+     */
+    async resolveDependencies(nodesByModule) {
+        log_1.Log.debug('compiler', 'tree', 'Resolving dependencies');
+        const resolved = {};
+        Object.entries(nodesByModule).forEach(([module, nodes]) => {
+            log_1.Log.debug('compiler', 'tree', `Resolving dependencies of ${(0, log_1.scopeTag)('module', module)}`);
+            nodes.forEach(node => {
+                log_1.Log.trace('compiler', 'tree', ` └ ${(0, log_1.scopeTag)(node.type, node.name)}`);
+                const dependencies = node.dependencies.map(dep => {
+                    // Find dependency module
+                    const depModuleNodes = nodesByModule[dep.module || module];
+                    if (!depModuleNodes) {
+                        throw error_1.CompilerError.UnmetModuleDependency(node.name + '.' + node.type, dep.module || module);
+                    }
+                    // Find dependency node
+                    const depNode = depModuleNodes.find(mNode => mNode.tag === dep.tag);
+                    if (!depNode) {
+                        throw error_1.CompilerError.UnmetDependency(node.tag, dep.tag);
+                    }
+                    log_1.Log.trace('compiler', 'tree', `   ~ ${(0, string_1.colored)('OK', 'green')} ${(0, string_1.colored)(dep.module + '::' + dep.type + ':' + dep.name, 'purple')}`);
+                    // If dependency node was not resolved yet, create a shared reference
+                    // on which the `dependencies` and `inlines` will be populated on future iterations.
+                    if (!(dep.tag in resolved)) {
+                        resolved[dep.tag] = {
+                            ...depNode,
+                            dependencies: [],
+                            inlines: {}
+                        };
+                    }
+                    return { node: resolved[dep.tag], soft: dep.soft };
+                });
+                const inlines = {};
+                if ('_inlineNodes' in node.builder) {
+                    const inlineNodes = node.builder._inlineNodes;
+                    inlineNodes.forEach((inline) => {
+                        log_1.Log.trace('compiler', 'tree', `   └ ${(0, string_1.colored)('OK', 'green')} ${(0, string_1.colored)(inline.module + '::' + inline.type + ':' + inline.name, 'lightcyan')}`);
+                        // If inline node was not resolved yet, create a shared reference
+                        // on which the `dependencies` and `inlines` will be populated on future iterations.
+                        if (!(inline.tag in resolved)) {
+                            resolved[inline.tag] = {
+                                ...inline,
+                                dependencies: [],
+                                inlines: {}
+                            };
+                        }
+                        const type = inline.type;
+                        if (!(type in inlines)) {
+                            inlines[type] = {
+                                [inline.name]: resolved[inline.tag]
+                            };
+                        }
+                        inlines[type][inline.name] = resolved[inline.tag];
+                    });
+                }
+                // If node was already created when resolving a dependendant,
+                // just fill the dependencies and inlines.
+                if (node.tag in resolved) {
+                    resolved[node.tag].dependencies = dependencies;
+                    resolved[node.tag].inlines = inlines;
+                }
+                // If not, create the resolved node
+                else {
+                    resolved[node.tag] = {
+                        ...node,
+                        dependencies,
+                        inlines
+                    };
+                }
+            });
+        });
+        const resolvedNodes = Object.values(resolved);
+        // After building all nodes, resolve roots of inline nodes
+        // (the non-inline builder which contains the node)
+        resolvedNodes.forEach(node => {
+            if (node.isInline) {
+                return;
+            }
+            const inlines = this.getAllInlineNodes(node);
+            inlines.forEach(inline => {
+                inline.root = node;
+            });
+        });
+        // Remove from nodes the dependencies which are rooted on the node,
+        // but are not the node itself. (Inner dependencies)
+        // This is done because these dependencies should be correctly built by
+        // the node's builder.
+        resolvedNodes.forEach(node => {
+            node.dependencies = node.dependencies.filter(dep => dep.node.root != node);
+        });
+        return resolvedNodes;
+    }
+    getAllInlineNodes(node) {
+        const inlineNodes = [];
+        if (node.inlines.message) {
+            inlineNodes.push(...Object.values(node.inlines.message));
+        }
+        if (node.inlines.job) {
+            inlineNodes.push(...Object.values(node.inlines.job));
+        }
+        if (inlineNodes.length) {
+            Object.assign([], inlineNodes).forEach(inline => {
+                inlineNodes.push(...this.getAllInlineNodes(inline));
+            });
+        }
+        return inlineNodes;
+    }
+    /**
+     * In order to build nodes on the proper order, a set of layers must be stablished
+     */
+    resolveLayers(nodes) {
+        log_1.Log.debug('compiler', 'tree', 'Resolving Layers');
+        nodes.forEach(node => {
+            node._dependencies = [...(node.dependencies || [])]
+                .filter(dep => !dep.soft)
+                .map(dep => dep.node);
+        });
+        const layers = [];
+        while (nodes.length) {
+            log_1.Log.trace('compiler', 'tree', ` └ ${(0, string_1.colored)(`layer.${layers.length}`, 'lightblue')}`);
+            let layer = [];
+            const future = [];
+            nodes.forEach(node => {
+                // Node has no dependency, it belongs to the current list
+                // and can be flagged as seen.
+                if (node._dependencies.length == 0) {
+                    layer.push(node);
+                    node.layered = true;
+                    log_1.Log.trace('compiler', 'tree', `   └ ${node.module}::${(0, log_1.scopeTag)(node.type, node.name)}` + (node.root ? (0, string_1.colored)(` @ ${node.root?.tag}`, 'purple') : ''));
+                }
+                // Node has dependencies, so it must be on future layers.
+                else {
+                    future.push(node);
+                }
+            });
+            // Remove from future dependencies those who were already seen
+            future.forEach(node => {
+                node._dependencies = node._dependencies.filter(dep => !dep.layered);
+            });
+            // If all nodes have a dependency, this means there's at least 1 circular dependency
+            // Nesoi doesn't support partial building (yet?), so circular dependencies between blocks
+            // are not permitted.
+            if (future.length === nodes.length) {
+                nodes.forEach(node => {
+                    log_1.Log.trace('compiler', 'tree', `   └ ${(0, string_1.colored)('(future)', 'lightred')} ${node.module}::${(0, log_1.scopeTag)(node.type, node.name)}` + (node.root ? (0, string_1.colored)(` @ ${node.root?.tag}`, 'purple') : ''));
+                    log_1.Log.trace('compiler', 'tree', (0, string_1.colored)(`     depends on: ${node._dependencies.map(dep => dep.module + '::' + dep.type + ':' + dep.name + (dep.layered ? '(OK)' : '')).join(', ')}`, 'purple'));
+                });
+                throw error_1.CompilerError.CircularDependency();
+            }
+            nodes = future;
+            // Reorder layer so that externals are built first
+            const externals = layer.filter(node => node.type === 'externals');
+            const internals = layer.filter(node => node.type !== 'externals');
+            layer = [...externals, ...internals];
+            layers.push(layer);
+        }
+        layers.forEach(layer => {
+            layer.forEach(node => {
+                delete node.layered;
+                delete node._dependencies;
+            });
+        });
+        return layers;
+    }
+    async traverse(actionAlias, fn) {
+        for (let i = 0; i < this.layers.length; i++) {
+            const layer = this.layers[i];
+            log_1.Log.debug('compiler', 'tree', `${actionAlias} ${(0, log_1.scopeTag)('layer', i.toString())}`);
+            for (const node of layer) {
+                await fn(node);
+            }
+        }
+    }
+    getSchema(node) {
+        const mod = this.modules[node.module];
+        if (node.type === 'constants')
+            return mod.schema.constants;
+        if (node.type === 'externals')
+            return mod.schema.externals;
+        if (node.type === 'bucket')
+            return mod.schema.buckets[node.name];
+        if (node.type === 'message')
+            return mod.schema.messages[node.name];
+        if (node.type === 'job')
+            return mod.schema.jobs[node.name];
+        if (node.type === 'resource')
+            return mod.schema.resources[node.name];
+        if (node.type === 'machine')
+            return mod.schema.machines[node.name];
+        if (node.type === 'controller')
+            return mod.schema.controllers[node.name];
+        throw error_1.CompilerError.UnmetDependency('tree', node.name);
+    }
+    allNodes() {
+        const nodes = [];
+        for (const layer of this.layers) {
+            for (const node of layer) {
+                nodes.push(node);
+            }
+        }
+        return nodes;
+    }
+}
+exports.ModuleTree = ModuleTree;

package/lib/engine/util/cache.d.ts

@@ -0,0 +1,6 @@
+export default class Cache<T> {
+    private data;
+    constructor(data?: Record<string, T>);
+    set(key: string, val: T): void;
+    get(key: string, set: () => T | undefined): T;
+}

package/lib/engine/util/cache.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Cache {
+    constructor(data = {}) {
+        this.data = data;
+    }
+    set(key, val) {
+        this.data[key] = val;
+    }
+    get(key, set) {
+        if (!(key in this.data)) {
+            const val = set();
+            if (val) {
+                this.data[key] = val;
+            }
+        }
+        return this.data[key];
+    }
+}
+exports.default = Cache;

package/lib/engine/util/console.d.ts

@@ -0,0 +1,4 @@
+export default class Console {
+    static step(msg: string): void;
+    static header(module: string): void;
+}

package/lib/engine/util/console.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const package_json_1 = __importDefault(require("../../../package.json"));
+const string_1 = require("./string");
+class Console {
+    // Prints a step message to the terminal
+    static step(msg) {
+        console.log((0, string_1.colored)('- ' + msg, 'green'));
+    }
+    // Prints the header
+    static header(module) {
+        console.log((0, string_1.colored)('┏          ┓', 'lightcyan'));
+        console.log((0, string_1.colored)('  ┏┓┳┓┏┏┓┏', 'lightblue'));
+        console.log((0, string_1.colored)('  ┛╹┗ ┛┗┛╹', 'lightblue'));
+        console.log((0, string_1.colored)('┗          ┛', 'lightcyan'));
+        console.log((0, string_1.colored)('       ' + package_json_1.default.version, 'lightblue'));
+        console.log((0, string_1.colored)('\n[ ' + module + ' ]', 'lightpurple'));
+        console.log();
+    }
+}
+exports.default = Console;

package/lib/engine/util/deep.d.ts

@@ -0,0 +1,7 @@
+import { UndefinedToOptional } from '../data/obj';
+export type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+export type DeepPartialNullable<T> = UndefinedToOptional<T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]> | null;
+} : T>;

package/lib/engine/util/deep.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/engine/util/dotenv.d.ts

@@ -0,0 +1,15 @@
+export type DotEnvFile = Record<string, string>;
+export declare class DotEnv {
+    static path: string;
+    static load(): DotEnvFile;
+    static save(dotenv: DotEnvFile): void;
+    static get(key: string): string;
+    static set(key: string, value: string): void;
+}
+export type DotEnvValidatorFile = Record<string, string>;
+export declare class DotEnvValidator {
+    static path: string;
+    static load(): DotEnvValidatorFile;
+    static save(validator: DotEnvValidatorFile): void;
+    static set(key: string, type: 'string' | 'number' | 'enum', args?: any): void;
+}

package/lib/engine/util/dotenv.js

@@ -0,0 +1,94 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DotEnvValidator = exports.DotEnv = void 0;
+const fs = __importStar(require("fs"));
+class DotEnv {
+    static load() {
+        const file = fs.readFileSync(this.path, 'utf-8');
+        return file.split('\n').reduce((a, line) => {
+            const p = line.split('=');
+            if (p.length > 1)
+                a[p[0]] = line.split('=')[1];
+            return a;
+        }, {});
+    }
+    static save(dotenv) {
+        const file = Object.keys(dotenv).map(p => p + '=' + dotenv[p]).join('\n');
+        fs.writeFileSync(this.path, file);
+    }
+    static get(key) {
+        const dotenv = this.load();
+        return dotenv[key];
+    }
+    static set(key, value) {
+        const dotenv = this.load();
+        dotenv[key] = value;
+        this.save(dotenv);
+    }
+}
+exports.DotEnv = DotEnv;
+DotEnv.path = '.env';
+class DotEnvValidator {
+    static load() {
+        const file = fs.readFileSync(this.path, 'utf-8');
+        const regex = new RegExp(/(\S*?): (.*)\)[, $\n]/gm);
+        const validator = {};
+        let entry = regex.exec(file);
+        while (entry) {
+            validator[entry[1]] = entry[2] + ')';
+            entry = regex.exec(file);
+        }
+        return validator;
+    }
+    static save(validator) {
+        let file = 'import Env from \'@ioc:Adonis/Core/Env\'\n\n';
+        file += 'export default Env.rules({\n';
+        file += Object.keys(validator).map(p => '\t' + p + ': ' + validator[p]).join(',\n');
+        file += '\n})';
+        fs.writeFileSync(this.path, file);
+    }
+    static set(key, type, args) {
+        const validator = this.load();
+        if (args)
+            args = JSON.stringify(args) + ' as const';
+        else
+            args = '';
+        validator[key] = `Env.schema.${type}(${args})`;
+        this.save(validator);
+    }
+}
+exports.DotEnvValidator = DotEnvValidator;
+DotEnvValidator.path = 'env.ts';

package/lib/engine/util/i18n.d.ts

@@ -0,0 +1,5 @@
+import { AnyDaemon } from '../daemon';
+import { NesoiError } from '../data/error';
+export declare class i18n {
+    static error(error: NesoiError.BaseError, daemon?: AnyDaemon): string;
+}

package/lib/engine/util/i18n.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.i18n = void 0;
+const daemon_1 = require("../daemon");
+class i18n {
+    static error(error, daemon) {
+        if (!daemon) {
+            return error.toString();
+        }
+        const strings = daemon_1.Daemon.get(daemon, 'app')?.i18n || {};
+        if (error.name in strings) {
+            const msg = strings[error.name](error.data || {});
+            error.message = msg;
+            return msg;
+        }
+        return error.toString();
+    }
+}
+exports.i18n = i18n;

package/lib/engine/util/log.d.ts

@@ -0,0 +1,17 @@
+import { $BlockType } from "../../elements/blocks/block.schema";
+declare const LogLevel: readonly ["off", "error", "warn", "info", "debug", "trace"];
+export type LogLevel = typeof LogLevel[number];
+export type LogScope = $BlockType | 'compiler' | 'trx' | 'daemon' | 'app' | 'module' | 'layer' | 'message' | 'bucket' | 'job' | 'resource' | 'controller' | 'queue' | 'constants' | 'externals';
+export declare function scopeTag(scope: LogScope, scope_id: string): string;
+export declare function anyScopeTag(scopeWithId: string): string;
+export declare class Log {
+    static level: LogLevel;
+    private static l;
+    static error(scope: LogScope, scope_id: string, message: string, obj?: Record<string, any>): void;
+    static warn(scope: LogScope, scope_id: string, message: string, obj?: Record<string, any>): void;
+    static info(scope: LogScope, scope_id: string, message: string, obj?: Record<string, any>): void;
+    static debug(scope: LogScope, scope_id: string, message: string, obj?: Record<string, any>): void;
+    static trace(scope: LogScope, scope_id: string, message: string, obj?: Record<string, any>): void;
+    private static push;
+}
+export {};