nesoi 3.0.0

package/lib/engine/data/error.js

@@ -0,0 +1,386 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NesoiError = void 0;
+var NesoiError;
+(function (NesoiError) {
+    class BaseError extends Error {
+        constructor(name, message, status = 500, data) {
+            super(message);
+            this.name = name;
+            this.status = status;
+            this.data = data;
+        }
+        toString() {
+            return `[${this.name}] ${this.message}`;
+        }
+    }
+    NesoiError.BaseError = BaseError;
+    let Status;
+    (function (Status) {
+        Status[Status["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+        Status[Status["NOT_FOUND"] = 404] = "NOT_FOUND";
+        Status[Status["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
+        Status[Status["INTERNAL_ERROR"] = 500] = "INTERNAL_ERROR";
+    })(Status || (Status = {}));
+    let Builder;
+    (function (Builder) {
+        let Job;
+        (function (Job) {
+            function NoMethod($) {
+                return new BaseError('Builder.Job.NoMethod', `Job '${$.job}' doesn't declare a method`, Status.INTERNAL_ERROR, $);
+            }
+            Job.NoMethod = NoMethod;
+        })(Job = Builder.Job || (Builder.Job = {}));
+        let Bucket;
+        (function (Bucket) {
+            function UnknownModelField(path) {
+                return new BaseError('Builder.Bucket.UnknownModelField', `Bucket model has no field ${path}`, Status.NOT_FOUND);
+            }
+            Bucket.UnknownModelField = UnknownModelField;
+            function UnknownGraphLink(name) {
+                return new BaseError('Builder.Bucket.UnknownGraphLink', `Bucket graph has no link ${name}`, Status.NOT_FOUND);
+            }
+            Bucket.UnknownGraphLink = UnknownGraphLink;
+            function UnknownViewName(name) {
+                return new BaseError('Builder.Bucket.UnknownViewName', `Bucket has no view ${name}`, Status.NOT_FOUND);
+            }
+            Bucket.UnknownViewName = UnknownViewName;
+            function NoChildrenOnViewGroup(name) {
+                return new BaseError('Builder.Bucket.NoChildrenOnViewGroup', `Bucket view group ${name} has no children`, Status.NOT_FOUND);
+            }
+            Bucket.NoChildrenOnViewGroup = NoChildrenOnViewGroup;
+            function CompositionWithPivotNotAllowed() {
+                return new BaseError('Builder.Bucket.CompositionWithPivotNotAllowed', 'Composition with pivot is not allowed', Status.NOT_FOUND);
+            }
+            Bucket.CompositionWithPivotNotAllowed = CompositionWithPivotNotAllowed;
+        })(Bucket = Builder.Bucket || (Builder.Bucket = {}));
+        let Message;
+        (function (Message) {
+            function UnknownTemplateFieldType(type) {
+                return new BaseError('Builder.Message.UnknownTemplateFieldType', `Message field has unknown type ${type}`, Status.NOT_FOUND);
+            }
+            Message.UnknownTemplateFieldType = UnknownTemplateFieldType;
+            function UnknownModuleMessage(name) {
+                return new BaseError('Builder.Message.UnknownModuleMessage', `Message ${name} not found on module`, Status.NOT_FOUND);
+            }
+            Message.UnknownModuleMessage = UnknownModuleMessage;
+        })(Message = Builder.Message || (Builder.Message = {}));
+        let Resource;
+        (function (Resource) {
+            function BucketNotFound(resource, bucket) {
+                return new BaseError('Builder.Resource.BucketRequired', `Resource ${resource} declares an unknown bucket ${bucket}`, Status.NOT_FOUND);
+            }
+            Resource.BucketNotFound = BucketNotFound;
+            function CustomInputRequiresPrepare(resource) {
+                return new BaseError('Builder.Resource.CustomInputRequiresPrepare', `Resource job '${resource}' declares a custom input, so it must declare a prepare method.`, Status.NOT_FOUND);
+            }
+            Resource.CustomInputRequiresPrepare = CustomInputRequiresPrepare;
+        })(Resource = Builder.Resource || (Builder.Resource = {}));
+    })(Builder = NesoiError.Builder || (NesoiError.Builder = {}));
+    let App;
+    (function (App) {
+        function ModuleNotFound(module) {
+            return new BaseError('App.ModuleNotFound', `Module ${module} not found on app space`, Status.NOT_FOUND);
+        }
+        App.ModuleNotFound = ModuleNotFound;
+    })(App = NesoiError.App || (NesoiError.App = {}));
+    let Module;
+    (function (Module) {
+        function UnknownBuilderType(module, filename, key, $b) {
+            return new BaseError('Module.UnknownBuilderType', `File ${filename} contains an unknown builder type '${$b}' exported as '${key}'`, Status.NOT_FOUND);
+        }
+        Module.UnknownBuilderType = UnknownBuilderType;
+        function EnumNotFound(module, name) {
+            return new BaseError('Module.EnumNotFound', `Enum ${name} not found on module ${module.name}`, Status.NOT_FOUND);
+        }
+        Module.EnumNotFound = EnumNotFound;
+        function JobNotIncluded(module, job) {
+            return new BaseError('Module.JobNotIncluded', `Job ${job} not included on module ${module.name}`, Status.NOT_FOUND);
+        }
+        Module.JobNotIncluded = JobNotIncluded;
+        function ResourceNotIncluded(module, resource) {
+            return new BaseError('Module.ResourceNotIncluded', `Resource ${resource} not included on module ${module.name}`, Status.NOT_FOUND);
+        }
+        Module.ResourceNotIncluded = ResourceNotIncluded;
+        function MachineNotIncluded(module, machine) {
+            return new BaseError('Module.MachineNotIncluded', `Machine ${machine} not included on module ${module.name}`, Status.NOT_FOUND);
+        }
+        Module.MachineNotIncluded = MachineNotIncluded;
+        function QueueNotIncluded(module, queue) {
+            return new BaseError('Module.QueueNotIncluded', `Queue ${queue} not included on module ${module.name}`, Status.NOT_FOUND);
+        }
+        Module.QueueNotIncluded = QueueNotIncluded;
+        function ControllerNotIncluded(module, controller) {
+            return new BaseError('Module.ControllerNotIncluded', `Controller ${controller} not included on module ${module.name}`, Status.NOT_FOUND);
+        }
+        Module.ControllerNotIncluded = ControllerNotIncluded;
+        function InlineMessageNotFoundOnMerge(msg) {
+            return new BaseError('Module.InlineMessageNotFoundOnMerge', `Inline message ${msg} not found during merge`, Status.NOT_FOUND);
+        }
+        Module.InlineMessageNotFoundOnMerge = InlineMessageNotFoundOnMerge;
+        function InlineJobNotFoundOnMerge(job) {
+            return new BaseError('Module.InlineJobNotFoundOnMerge', `Inline job ${job} not found during merge`, Status.NOT_FOUND);
+        }
+        Module.InlineJobNotFoundOnMerge = InlineJobNotFoundOnMerge;
+    })(Module = NesoiError.Module || (NesoiError.Module = {}));
+    let Authn;
+    (function (Authn) {
+        function NoProvidersRegisteredForModule(module) {
+            return new BaseError('Authn.NoProvidersRegisteredForModule', `No authentication providers registered for module ${module}`, Status.NOT_FOUND);
+        }
+        Authn.NoProvidersRegisteredForModule = NoProvidersRegisteredForModule;
+        function NoProviderRegisteredForModule(module, provider) {
+            return new BaseError('Authn.NoProviderRegisteredForModule', `No authentication provider named ${provider} registered for module ${module}`, Status.NOT_FOUND);
+        }
+        Authn.NoProviderRegisteredForModule = NoProviderRegisteredForModule;
+        function NoUsersAuthenticatedForTrxNode(globalId) {
+            return new BaseError('Authn.NoUsersAuthenticatedForTrxNode', `No users authenticated for trx node ${globalId}`, Status.NOT_FOUND);
+        }
+        Authn.NoUsersAuthenticatedForTrxNode = NoUsersAuthenticatedForTrxNode;
+    })(Authn = NesoiError.Authn || (NesoiError.Authn = {}));
+    let Trx;
+    (function (Trx) {
+        function ModuleNotFound(module) {
+            return new BaseError('Trx.ModuleNotFound', `Module ${module} not found on app`, Status.NOT_FOUND);
+        }
+        Trx.ModuleNotFound = ModuleNotFound;
+        function NodeNotFound(node, trx) {
+            return new BaseError('Trx.NodeNotFoundOnTrx', `Node ${node} not found on transaction ${trx}`, Status.NOT_FOUND);
+        }
+        Trx.NodeNotFound = NodeNotFound;
+    })(Trx = NesoiError.Trx || (NesoiError.Trx = {}));
+    /*
+        Elements / Entities
+    */
+    let Bucket;
+    (function (Bucket) {
+        function InvalidId($) {
+            return new BaseError('Bucket.InvalidId', `Read attempt of '${$.bucket}' failed with invalid id '${$.id}'`, Status.BAD_REQUEST, $);
+        }
+        Bucket.InvalidId = InvalidId;
+        function ObjNotFound($) {
+            return new BaseError('Bucket.ObjNotFound', `Bucket '${$.bucket}' has no object with id '${$.id}'`, Status.NOT_FOUND, $);
+        }
+        Bucket.ObjNotFound = ObjNotFound;
+        function ViewNotFound($) {
+            return new BaseError('Bucket.ViewNotFound', `Bucket '${$.bucket}' has no view named '${$.view}'`, Status.NOT_FOUND, $);
+        }
+        Bucket.ViewNotFound = ViewNotFound;
+        function NoUpdatedAtField($) {
+            return new BaseError('Bucket.NoUpdatedAtField', `Bucket '${$.bucket}' object with id '${$.id}' has no '${$.field}' field (required for cache)`, Status.PRECONDITION_FAILED, $);
+        }
+        Bucket.NoUpdatedAtField = NoUpdatedAtField;
+        function MissingComposition($) {
+            return new BaseError('Bucket.MissingComposition', `Request to ${$.method} bucket '${$.bucket}' failed, missing composition for link ${$.link}`, Status.BAD_REQUEST);
+        }
+        Bucket.MissingComposition = MissingComposition;
+        function CompositionValueShouldBeArray($) {
+            return new BaseError('Bucket.CompositionValueShouldBeArray', `Request to ${$.method} bucket '${$.bucket}' failed, composition for link ${$.link} should be an array`, Status.BAD_REQUEST, $);
+        }
+        Bucket.CompositionValueShouldBeArray = CompositionValueShouldBeArray;
+        let Graph;
+        (function (Graph) {
+            function LinkNotFound($) {
+                return new BaseError('Bucket.Graph.LinkNotFound', `Bucket '${$.bucket}' has no graph link named '${$.link}'`, Status.NOT_FOUND, $);
+            }
+            Graph.LinkNotFound = LinkNotFound;
+            function LinkManyRefOnSelfWithoutArrayValue(link) {
+                return new BaseError('Bucket.Graph.LinkManyRefOnSelfWithoutArrayValue', `Link ${link} is a 1..n relation with key on self, which requires an array as value for reading`, Status.NOT_FOUND);
+            }
+            Graph.LinkManyRefOnSelfWithoutArrayValue = LinkManyRefOnSelfWithoutArrayValue;
+            function LinkManyRefOffSelfWithArrayValue(link) {
+                return new BaseError('Bucket.Graph.LinkManyRefOffSelfWithArrayValue', `Link ${link} is a 1..n relation with key on other/pivot, which does not support an array as value for reading`, Status.NOT_FOUND);
+            }
+            Graph.LinkManyRefOffSelfWithArrayValue = LinkManyRefOffSelfWithArrayValue;
+            function LinkOneWithArrayValue(link) {
+                return new BaseError('Bucket.Graph.LinkOneWithArrayValue', `Link ${link} is a 1..1 relation, which does not support an array as value for reading`, Status.NOT_FOUND);
+            }
+            Graph.LinkOneWithArrayValue = LinkOneWithArrayValue;
+            function PivotValueIsUndefined(link) {
+                return new BaseError('Bucket.Graph.PivotValueIsUndefined', `Link ${link} has a pivot value with undefined/null on the other id`, Status.NOT_FOUND);
+            }
+            Graph.PivotValueIsUndefined = PivotValueIsUndefined;
+            function RequiredLinkNotFound(link, value) {
+                return new BaseError('Bucket.Graph.RequiredLinkNotFound', `Link ${link} value not found for value ${value}`, Status.NOT_FOUND);
+            }
+            Graph.RequiredLinkNotFound = RequiredLinkNotFound;
+        })(Graph = Bucket.Graph || (Bucket.Graph = {}));
+        let Query;
+        (function (Query) {
+            function NoResults($) {
+                return new BaseError('Bucket.Query.NoResults', `Query to bucket '${$.bucket}' returned no results`, Status.NOT_FOUND, $);
+            }
+            Query.NoResults = NoResults;
+            function ViewNotFound(bucket, view) {
+                return new BaseError('Bucket.Query.InvalidObjectValueType', `View ${view} not found on bucket ${bucket}, required for querying`, Status.NOT_FOUND);
+            }
+            Query.ViewNotFound = ViewNotFound;
+            function PathNotFoundOnView(path, view) {
+                return new BaseError('Bucket.Query.PathNotFoundOnView', `Path ${path} was not found on view ${view}`, Status.NOT_FOUND);
+            }
+            Query.PathNotFoundOnView = PathNotFoundOnView;
+            function NonModelSearchNotImplemented(path, view) {
+                return new BaseError('Bucket.Query.NonModelSearchNotImplemented', `Query for ${path} on view ${view} failed because it's not a model field. Computed and graph fields should be implemented soon.`, Status.NOT_FOUND);
+            }
+            Query.NonModelSearchNotImplemented = NonModelSearchNotImplemented;
+            function InvalidRuleValueType(path, type) {
+                return new BaseError('Bucket.Query.InvalidFieldValueType', `Rule ${path} is not a ${type}`, Status.NOT_FOUND);
+            }
+            Query.InvalidRuleValueType = InvalidRuleValueType;
+            function InvalidOpForFieldType(path, op, type) {
+                return new BaseError('Bucket.Query.InvalidOpForFieldType', `Rule ${path} op ${op} if not supported by field ${type}`, Status.NOT_FOUND);
+            }
+            Query.InvalidOpForFieldType = InvalidOpForFieldType;
+        })(Query = Bucket.Query || (Bucket.Query = {}));
+        let Fieldpath;
+        (function (Fieldpath) {
+            function InvalidIndexLength($) {
+                return new BaseError('Bucket.Fieldpath.InvalidIndexLength', `Attempt to parse fieldpath '${$.fieldpath}' failed due to invalid number of indexes: ${$.index}`, Status.BAD_REQUEST, $);
+            }
+            Fieldpath.InvalidIndexLength = InvalidIndexLength;
+        })(Fieldpath = Bucket.Fieldpath || (Bucket.Fieldpath = {}));
+    })(Bucket = NesoiError.Bucket || (NesoiError.Bucket = {}));
+    let Data;
+    (function (Data) {
+        function InvalidISOString($) {
+            return new BaseError('Message.Data.InvalidISOString', `'${$.value}' is not a valid ISO string`, Status.BAD_REQUEST, $);
+        }
+        Data.InvalidISOString = InvalidISOString;
+        function UnsupportedDecimalPrecision($) {
+            return new BaseError('Message.Data.UnsupportedDecimalPrecision', `Decimal precision [${$.left},${$.right}]' is invalid. Supported range: 1~12.`, Status.BAD_REQUEST, $);
+        }
+        Data.UnsupportedDecimalPrecision = UnsupportedDecimalPrecision;
+        function DecimalLeftTooBig($) {
+            return new BaseError('Message.Data.DecimalLeftTooBig', `Left part of decimal value '${$.value}' exceeds precision of ${$.prec}`, Status.BAD_REQUEST, $);
+        }
+        Data.DecimalLeftTooBig = DecimalLeftTooBig;
+        function DecimalRightTooBig($) {
+            return new BaseError('Message.Data.DecimalRightTooBig', `Right part of decimal value '${$.value}' exceeds precision of ${$.prec}`, Status.BAD_REQUEST, $);
+        }
+        Data.DecimalRightTooBig = DecimalRightTooBig;
+        function InvalidDecimalValue($) {
+            return new BaseError('Message.Data.InvalidDecimalValue', `Invalid decimal value '${$.value}'`, Status.BAD_REQUEST, $);
+        }
+        Data.InvalidDecimalValue = InvalidDecimalValue;
+    })(Data = NesoiError.Data || (NesoiError.Data = {}));
+    let Message;
+    (function (Message) {
+        function NoType($) {
+            return new BaseError('Message.NoType', 'Message has no "$" prop', Status.BAD_REQUEST, $);
+        }
+        Message.NoType = NoType;
+        function InvalidType($) {
+            return new BaseError('Message.InvalidType', `Message prop "$" is an invalid value: ${$.type}`, Status.BAD_REQUEST, $);
+        }
+        Message.InvalidType = InvalidType;
+        function NotSupportedByModule($) {
+            return new BaseError('Message.NotSupportedByModule', `Message of type '${$.type}' is not supported by module '${$.module}'`, Status.BAD_REQUEST, $);
+        }
+        Message.NotSupportedByModule = NotSupportedByModule;
+        function InvalidEnumScope(prop, value, fieldpath) {
+            return new BaseError('Message.InvalidEnumScope', `${prop.alias || prop.name} is an enum with dynamic scope, and the path '${fieldpath}' of the message has an invalid value '${value}'`);
+        }
+        Message.InvalidEnumScope = InvalidEnumScope;
+        function InvalidFieldEnumValue($) {
+            return new BaseError('Message.InvalidFieldEnumValue', `Message field '${$.field}' value '${$.value}' should be one of the following: ${$.options?.join(',')}`, Status.BAD_REQUEST, $);
+        }
+        Message.InvalidFieldEnumValue = InvalidFieldEnumValue;
+        function InvalidFieldType($) {
+            return new BaseError('Message.InvalidFieldType', `Message field '${$.field}' value '${$.value}' is not of type '${$.type}'`, Status.BAD_REQUEST, $);
+        }
+        Message.InvalidFieldType = InvalidFieldType;
+        function UnsanitaryValue($) {
+            return new BaseError('Message.UnsanitaryValue', $.details, Status.BAD_REQUEST, $);
+        }
+        Message.UnsanitaryValue = UnsanitaryValue;
+        function FieldIsRequired($) {
+            return new BaseError('Message.FieldIsRequired', `Field ${$.field} (${$.path}) is required`, Status.BAD_REQUEST, $);
+        }
+        Message.FieldIsRequired = FieldIsRequired;
+        function RuleFailed(rule, error) {
+            return new BaseError('Message.RuleFailed', error);
+        }
+        Message.RuleFailed = RuleFailed;
+        function FileTooBig(prop, maxSize) {
+            return new BaseError('Message.FileTooBig', `${prop.alias || prop.name} size exceeds max (${maxSize})`);
+        }
+        Message.FileTooBig = FileTooBig;
+        function FileExtNotAllowed(prop, options) {
+            return new BaseError('Message.FileExtNotAllowed', `${prop.alias || prop.name} extension not allowed. Options: ${options}`);
+        }
+        Message.FileExtNotAllowed = FileExtNotAllowed;
+    })(Message = NesoiError.Message || (NesoiError.Message = {}));
+    /*
+        Elements / Blocks
+    */
+    let Block;
+    (function (Block) {
+        function InvalidSchema($) {
+            return new BaseError('Block.InvalidSchema', `Schema '${$.name}' has invalid type '${$.type}'. Expected ${$.expectedType}.`, Status.INTERNAL_ERROR, $);
+        }
+        Block.InvalidSchema = InvalidSchema;
+        function MessageNotSupported($) {
+            return new BaseError('Block.MessageNotSupported', `Block '${$.block}' expects no message of type '${$.message}'.`, Status.BAD_REQUEST, $);
+        }
+        Block.MessageNotSupported = MessageNotSupported;
+    })(Block = NesoiError.Block || (NesoiError.Block = {}));
+    let Job;
+    (function (Job) {
+        function ConditionUnmet($) {
+            return new BaseError('Job.ConditionUnmet', `${$.job} condition unmet: ${$.error}`, Status.BAD_REQUEST, $);
+        }
+        Job.ConditionUnmet = ConditionUnmet;
+    })(Job = NesoiError.Job || (NesoiError.Job = {}));
+    let Resource;
+    (function (Resource) {
+        function ViewNotSupported(resource) {
+            return new BaseError('Resource.ViewNotSupported', `Resource ${resource.name} doesn't support 'view'.`, Status.NOT_FOUND);
+        }
+        Resource.ViewNotSupported = ViewNotSupported;
+        function QueryNotSupported(resource) {
+            return new BaseError('Resource.QueryNotSupported', `Resource ${resource.name} doesn't support 'query'.`, Status.NOT_FOUND);
+        }
+        Resource.QueryNotSupported = QueryNotSupported;
+        function CreateNotSupported(resource) {
+            return new BaseError('Resource.CreateNotSupported', `Resource ${resource.name} doesn't support 'create'.`, Status.NOT_FOUND);
+        }
+        Resource.CreateNotSupported = CreateNotSupported;
+        function UpdateNotSupported(resource) {
+            return new BaseError('Resource.UpdateNotSupported', `Resource ${resource.name} doesn't support 'update'.`, Status.NOT_FOUND);
+        }
+        Resource.UpdateNotSupported = UpdateNotSupported;
+        function DeleteNotSupported(resource) {
+            return new BaseError('Resource.DeleteNotSupported', `Resource ${resource.name} doesn't support 'delete'.`, Status.NOT_FOUND);
+        }
+        Resource.DeleteNotSupported = DeleteNotSupported;
+    })(Resource = NesoiError.Resource || (NesoiError.Resource = {}));
+    let Machine;
+    (function (Machine) {
+        function MessageHasNoId(alias) {
+            return new BaseError('Machine.MessageHasNoId', `${alias} received message has no 'id'`, Status.NOT_FOUND);
+        }
+        Machine.MessageHasNoId = MessageHasNoId;
+        function ObjNotFound(alias, id) {
+            return new BaseError('Machine.ObjNotFound', `${alias} object with id ${id} not found`, Status.NOT_FOUND);
+        }
+        Machine.ObjNotFound = ObjNotFound;
+        function StateNotFound(alias, id) {
+            return new BaseError('Machine.StateNotFound', `${alias} state with id ${id} not found`, Status.NOT_FOUND);
+        }
+        Machine.StateNotFound = StateNotFound;
+        function UnmetCondition(alias, msg) {
+            return new BaseError('Machine.UnmetCondition', `${alias}: ${msg}`, Status.NOT_FOUND);
+        }
+        Machine.UnmetCondition = UnmetCondition;
+    })(Machine = NesoiError.Machine || (NesoiError.Machine = {}));
+    /*
+        Elements / Edge
+    */
+    let Controller;
+    (function (Controller) {
+        function PortNotFound(controller, port) {
+            return new BaseError('Controller.PortNotFound', `Port ${port} not found on controller ${controller.name}`, Status.NOT_FOUND);
+        }
+        Controller.PortNotFound = PortNotFound;
+    })(Controller = NesoiError.Controller || (NesoiError.Controller = {}));
+})(NesoiError || (exports.NesoiError = NesoiError = {}));

package/lib/engine/data/obj.d.ts

@@ -0,0 +1,16 @@
+export type NesoiObjId = number | string;
+export interface NesoiObj {
+    id: NesoiObjId;
+}
+export type NewOrOldObj<T extends NesoiObj> = {
+    id?: T['id'];
+} & Omit<T, 'id'>;
+type DefinedKeys<T> = {
+    [P in keyof T]: T[P] extends Exclude<T[P], undefined> ? P : never;
+}[keyof T];
+type DefinedProps<T> = Pick<T, DefinedKeys<T>>;
+export type UndefinedToOptional<T> = Partial<T> & DefinedProps<T>;
+export type DeepUndefinedToOptional<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepUndefinedToOptional<T[P]> : T[P];
+} & DefinedProps<T>;
+export {};

package/lib/engine/data/obj.js

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

package/lib/engine/data/tree.d.ts

@@ -0,0 +1,17 @@
+type TreeNode<T> = {
+    path: string;
+    key: string;
+    value: T;
+};
+export declare class Tree {
+    /**
+     * When the fieldpath contains a `.*.`, which refers to a item in a list:
+     * - If the `index` parameter is null, returns nested lists
+     * - If the `index` parameter is a list of indices, returns the target object
+     *
+     */
+    static get(obj: Record<string, any>, fieldpath: string, index?: 0 | null | (number | string)[]): any;
+    static find<P>(obj: Record<string, P>, fn: (path: string, value: P) => boolean, link?: string, _prefix?: string): TreeNode<P> | undefined;
+    static findAll<P>(obj: Record<string, P>, fn: (path: string, value: P) => boolean, _prefix?: string): TreeNode<P>[];
+}
+export {};

package/lib/engine/data/tree.js

@@ -0,0 +1,111 @@
+"use strict";
+/*
+    Tree methods
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tree = void 0;
+const error_1 = require("./error");
+class Tree {
+    /**
+     * When the fieldpath contains a `.*.`, which refers to a item in a list:
+     * - If the `index` parameter is null, returns nested lists
+     * - If the `index` parameter is a list of indices, returns the target object
+     *
+     */
+    static get(obj, fieldpath, index = []) {
+        index = (!Array.isArray(index)) ? index : [...index];
+        const paths = fieldpath.split('.');
+        const pathIndexCount = paths.filter(p => p === '*').length;
+        if (Array.isArray(index) && pathIndexCount > index.length) {
+            throw error_1.NesoiError.Bucket.Fieldpath.InvalidIndexLength({ fieldpath, index });
+        }
+        let ref = obj;
+        for (let i = 0; i < paths.length; i++) {
+            const path = paths[i];
+            if (path === '*') {
+                // 0 index, read the first item from the list
+                if (index === 0) {
+                    // This is a ObjTypeAsObj, stay on the node
+                    if ('__array' in ref) {
+                        // 
+                    }
+                    else {
+                        if (!Array.isArray(ref)) {
+                            return undefined;
+                        }
+                        ref = ref[0];
+                    }
+                }
+                // Null index, return a list of all items
+                else if (index === null) {
+                    if (!Array.isArray(ref)) {
+                        return undefined;
+                    }
+                    const childPath = paths.slice(i + 1);
+                    if (childPath.length === 0) {
+                        return ref;
+                    }
+                    return ref.map(v => this.get(v, childPath.join('.'), null));
+                }
+                // List of indices, advance on it
+                else {
+                    const idx = index.shift();
+                    if (idx === undefined) {
+                        return undefined;
+                    }
+                    ref = ref[idx];
+                }
+            }
+            else {
+                ref = ref[path];
+            }
+            if (ref === undefined) {
+                return undefined;
+            }
+        }
+        return ref;
+    }
+    static find(obj, fn, link, _prefix) {
+        const root = link ? obj[link] : obj;
+        for (const key in root) {
+            const prop = root[key];
+            const path = (_prefix ? _prefix + '.' : '') + key;
+            if (fn(path, prop)) {
+                return {
+                    path,
+                    key,
+                    value: prop
+                };
+            }
+            if (typeof prop === 'object'
+                && !Array.isArray(prop)
+                && !prop['__type']) {
+                const inner = this.find(prop, fn, link, path);
+                if (inner) {
+                    return inner;
+                }
+            }
+        }
+    }
+    static findAll(obj, fn, _prefix) {
+        const nodes = [];
+        for (const key in obj) {
+            const prop = obj[key];
+            const path = (_prefix ? _prefix + '.' : '') + key;
+            if (typeof prop === 'object'
+                && !Array.isArray(prop)
+                && !prop['__type']) {
+                nodes.push(...this.findAll(prop, fn, key));
+            }
+            if (fn(path, prop)) {
+                nodes.push({
+                    path,
+                    key,
+                    value: prop
+                });
+            }
+        }
+        return nodes;
+    }
+}
+exports.Tree = Tree;

package/lib/engine/dependency.d.ts

@@ -0,0 +1,68 @@
+import { BuilderType } from "../schema";
+import { AnyBuilder, AnyElementSchema } from './module';
+import { Overlay } from './util/type';
+import { JobBuilderNode } from "../elements/blocks/job/job.builder";
+import { MessageBuilderNode } from "../elements/entities/message/message.builder";
+import { ResourceJobBuilderNode } from "../elements/blocks/job/internal/resource_job.builder";
+import { BucketFnExtract, JobFnExtract, MachineFnExtract, MessageFnExtract } from "../compiler/typescript/bridge/organize";
+import { MachineJobBuilderNode } from "../elements/blocks/job/internal/machine_job.builder";
+export declare class $Tag {
+    static parse(tag: string): {
+        module: string | undefined;
+        type: string | undefined;
+        name: string;
+    } | undefined;
+    static parseOrFail(tag: string): {
+        module: string;
+        type: string;
+        name: string;
+    };
+}
+export declare class $Dependency {
+    module: string;
+    type: BuilderType;
+    name: string;
+    tag: string;
+    refName: string;
+    soft: boolean;
+    constructor(fromModule: string, type: BuilderType, name: string, soft?: boolean);
+    static typeName(dep: $Dependency, fromModule: string): string;
+}
+export declare class BuilderNode {
+    module: string;
+    type: BuilderType;
+    name: string;
+    tag: string;
+    isInline?: boolean;
+    filepath: string | string[];
+    dependencies: $Dependency[];
+    builder: AnyBuilder;
+    constructor($: {
+        module: string;
+        type: BuilderType;
+        name: string;
+        isInline?: boolean;
+        filepath: string | string[];
+        dependencies: $Dependency[];
+        builder: AnyBuilder;
+    });
+}
+export type ResolvedBuilderNode = Overlay<BuilderNode, {
+    _dependencies?: ResolvedBuilderNode[];
+    dependencies: {
+        node: ResolvedBuilderNode;
+        soft: boolean;
+    }[];
+    inlines: {
+        message?: Record<string, MessageBuilderNode>;
+        job?: Record<string, JobBuilderNode | ResourceJobBuilderNode | MachineJobBuilderNode>;
+    };
+    root?: ResolvedBuilderNode;
+    layered?: boolean;
+    schema?: AnyElementSchema;
+    bridge?: {
+        imports?: string[];
+        extract?: BucketFnExtract | MessageFnExtract | JobFnExtract | MachineFnExtract;
+        appDependencies?: $Dependency[];
+    };
+}>;