nesoi 3.2.9 → 3.3.1

package/lib/engine/dependency.d.ts

@@ -1,89 +1,66 @@
-import { $Module, BuilderType } from "../schema";
+import { $Module } 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";
+import { ModuleTree } from './tree';
+import { AnyTrxNode } from './transaction/trx_node';
+export type TagString = `${string}::${string}:${string}`;
+export type ShortTagString = `${string}::${string}`;
+export type TagType = 'constants' | 'constants.enum' | 'constants.value' | 'message' | 'bucket' | 'job' | 'resource' | 'machine' | 'controller' | 'queue' | 'topic' | 'externals';
+import { BucketFnExtract, JobFnExtract, MachineFnExtract, MessageFnExtract } from "../compiler/typescript/bridge/organize";
+import { AnyExternalsBuilder } from "../elements/edge/externals/externals.builder";
 /**
- * Utility class for parsing element `tags`.
+ * A tag references an element on a given module.
+ * The short form can be used when the type is implicit.
  *
- * A `tag` is a string which references an element
- * on the `Space`, following one of the formats below:
- * ```
- * module::type:name
- * module::name
- * type:name
- * name
- * ```
+ * module::type:name -> full tag
+ * module::name      -> short tag
  *
  * @category Engine
  */
-export declare class $Tag {
-    /**
-     * Parse `module?`, `type?` and `name` from a tag string.
-     *
-     * @param tag A tag string
-     * @returns An object containing the parsed tag info or `undefined`
-     * if it's an invalid tag.
-     */
-    static parse(tag: string): {
-        module: string | undefined;
-        type: string | undefined;
-        name: string;
-    } | undefined;
-    /**
-     * Parse `module?`, `type?` and `name` from a tag string.
-     *
-     * @param tag A tag string
-     * @returns An object containing the parsed tag info
-     * @throws If it's an invalid tag
-     */
-    static parseOrFail(tag: string): {
-        module: string | undefined;
-        type: string | undefined;
-        name: string;
-    };
+export declare class Tag {
+    module: string;
+    type: TagType;
+    name: string;
+    full: TagString;
+    short: ShortTagString;
+    constructor(module: string, type: TagType, name: string);
+    static from(tag: TagString): Tag;
+    static fromShort(type: TagType, shortTag: ShortTagString): Tag;
+    static fromNameOrShort(module: string, type: TagType, nameOrShortTag: string): Tag;
+    static get unsafe(): typeof __unsafe_Tag;
+    static resolve(self: Tag, tree: ModuleTree): AnyElementSchema;
+    static resolveFrom(self: Tag, module: $Module): AnyElementSchema;
+    static resolveExternal(self: Tag, externals: AnyExternalsBuilder): Dependency;
+    static element(self: Tag, trx: AnyTrxNode): any;
+    static matches(self: Tag, other: Tag): boolean;
+    static isSameNodeAs(self: Tag, other: Tag): boolean;
+}
+export declare class __unsafe_Tag {
+    static from(tag: TagString): any;
+    static fromShort(type: TagType, shortTag: ShortTagString): any;
+    static fromNameOrShort(module: string, type: TagType, nameOrShortTag: string): any;
 }
 /**
- * A reference for an element, declared from another element.
+ * A link between two elements.
  *
  * @category Engine
  */
-export declare class $Dependency {
-    /** Low name of the module*/
-    module: string;
-    /** Type of node */
-    type: BuilderType;
-    /** Low name of the node */
-    name: string;
-    /** `module::type:name` */
-    tag: string;
-    /** `name` if dependency is local, `module::name` if is external */
-    refName: string;
-    /** If true, this dependency doesn't affect build order */
-    soft: boolean;
-    /**
-     * @param fromModule Name of module which uses this dependency
-     * @param type Type of referenced element
-     * @param name Name of referenced element
-     * @param soft True if this doesn't affect build order
-     */
-    constructor(fromModule: string, type: BuilderType, name: string, soft?: boolean);
-    /**
-     * Return the type name (UpperCamel) of the element
-     * referenced by a dependency.
-     *
-     * @param dep A `$Dependency` instance
-     * @param fromModule Name of dependant module
-     * @returns The type name of the dependency
-     */
-    static typeName(dep: $Dependency, fromModule: string): string;
-    static resolve(module: $Module, dep: {
-        type: string;
-        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 | undefined;
+export declare class Dependency {
+    fromModule: string;
+    tag: Tag;
+    external: boolean;
+    build: boolean;
+    compile: boolean;
+    runtime: boolean;
+    constructor(fromModule: string, tag: Tag, options?: {
+        build?: boolean;
+        compile?: boolean;
+        runtime?: boolean;
+    });
 }
 /**
  * A element builder, along with metadata required for building it.
@@ -91,24 +68,19 @@ export declare class $Dependency {
  * @category Engine
  */
 export declare class BuilderNode {
-    module: string;
-    type: BuilderType;
-    name: string;
-    tag: string;
+    tag: Tag;
     isInline?: boolean;
     filepath: string | string[];
-    dependencies: $Dependency[];
+    dependencies: Dependency[];
     builder: AnyBuilder;
     progressive?: {
         schema: AnyElementSchema;
     };
     constructor($: {
-        module: string;
-        type: BuilderType;
-        name: string;
+        tag: Tag;
         isInline?: boolean;
         filepath: string | string[];
-        dependencies: $Dependency[];
+        dependencies: Dependency[];
         builder: AnyBuilder;
         progressive?: {
             schema: AnyElementSchema;
@@ -122,7 +94,7 @@ export type ResolvedBuilderNode = Overlay<BuilderNode, {
     _dependencies?: ResolvedBuilderNode[];
     dependencies: {
         node: ResolvedBuilderNode;
-        soft: boolean;
+        dep: Dependency;
     }[];
     inlines: {
         message?: Record<string, MessageBuilderNode>;
@@ -134,6 +106,6 @@ export type ResolvedBuilderNode = Overlay<BuilderNode, {
     bridge?: {
         imports?: string[];
         extract?: BucketFnExtract | MessageFnExtract | JobFnExtract | MachineFnExtract;
-        appDependencies?: $Dependency[];
+        appDependencies?: Dependency[];
     };
 }>;

package/lib/engine/dependency.js

@@ -1,146 +1,275 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuilderNode = exports.$Dependency = exports.$Tag = void 0;
-const name_helpers_1 = require("../compiler/helpers/name_helpers");
+exports.BuilderNode = exports.Dependency = exports.__unsafe_Tag = exports.Tag = void 0;
+const trx_node_1 = require("./transaction/trx_node");
+/* @nesoi:browser ignore-end */
 /**
- * Utility class for parsing element `tags`.
+ * A tag references an element on a given module.
+ * The short form can be used when the type is implicit.
  *
- * A `tag` is a string which references an element
- * on the `Space`, following one of the formats below:
- * ```
- * module::type:name
- * module::name
- * type:name
- * name
- * ```
+ * module::type:name -> full tag
+ * module::name      -> short tag
  *
  * @category Engine
  */
-class $Tag {
-    /**
-     * Parse `module?`, `type?` and `name` from a tag string.
-     *
-     * @param tag A tag string
-     * @returns An object containing the parsed tag info or `undefined`
-     * if it's an invalid tag.
-     */
-    static parse(tag) {
-        const match = tag.match(/(.\w*?::)?(\w*?:)?(.*)/);
-        const module = match?.[1]?.slice(0, -2);
-        const type = match?.[2]?.slice(0, -1);
+class Tag {
+    constructor(module, type, name) {
+        this.module = module;
+        this.type = type;
+        this.name = name;
+        this.full = `${module}::${type}:${name}`;
+        this.short = `${module}::${name}`;
+    }
+    static from(tag) {
+        const match = tag.match(/(.+)::(.+):(.+)/);
+        const module = match?.[1];
+        const type = match?.[2];
         const name = match?.[3];
-        if (!match
-            || (module && module.includes(':'))
-            || (type && type.includes(':'))
-            || !name
-            || name.includes(':')) {
-            return;
-        }
-        return { module, type, name };
-    }
-    /**
-     * Parse `module?`, `type?` and `name` from a tag string.
-     *
-     * @param tag A tag string
-     * @returns An object containing the parsed tag info
-     * @throws If it's an invalid tag
-     */
-    static parseOrFail(tag) {
-        const match = tag.match(/(.\w*?::)?(\w*?:)?(.*)/);
         if (!match) {
             throw new Error(`Internal error: Invalid tag ${tag}`);
         }
-        const module = match[1]?.slice(0, -2);
-        if (module && module.includes(':')) {
-            throw new Error(`Internal error: Invalid tag ${tag}, module ${module} includes invalid characters`);
+        if (!module) {
+            throw new Error(`Internal error: Invalid tag ${tag}, no module specified`);
         }
-        const type = match[2]?.slice(0, -1);
-        if (type && type.includes(':')) {
-            throw new Error(`Internal error: Invalid tag ${tag}, type ${type} includes invalid characters`);
+        if (!type) {
+            throw new Error(`Internal error: Invalid tag ${tag}, no type specified`);
         }
-        const name = match[3];
         if (!name) {
             throw new Error(`Internal error: Invalid tag ${tag}, no name specified`);
         }
+        if (module.includes(':')) {
+            throw new Error(`Internal error: Invalid tag ${tag}, module ${module} includes invalid characters`);
+        }
+        if (type.includes(':')) {
+            throw new Error(`Internal error: Invalid tag ${tag}, type ${type} includes invalid characters`);
+        }
         if (name.includes(':')) {
             throw new Error(`Internal error: Invalid tag ${tag}, name ${name} includes invalid characters`);
         }
-        return { module, type, name };
+        // TODO: validate type?
+        return new Tag(module, type, name);
+    }
+    static fromShort(type, shortTag) {
+        const match = shortTag.match(/(.+)::(.*)/);
+        const module = match?.[1];
+        const name = match?.[2];
+        if (!match) {
+            throw new Error(`Internal error: Invalid short tag ${shortTag}`);
+        }
+        if (!module) {
+            throw new Error(`Internal error: Invalid short tag ${shortTag}, no module specified`);
+        }
+        if (!name) {
+            throw new Error(`Internal error: Invalid short tag ${shortTag}, no name specified`);
+        }
+        if (module.includes(':')) {
+            throw new Error(`Internal error: Invalid short tag ${shortTag}, module ${module} includes invalid characters`);
+        }
+        if (name.includes(':')) {
+            throw new Error(`Internal error: Invalid short tag ${shortTag}, name ${name} includes invalid characters`);
+        }
+        return new Tag(module, type, name);
+    }
+    static fromNameOrShort(module, type, nameOrShortTag) {
+        const match = nameOrShortTag.match(/((.+)::)?(.*)/);
+        const tagModule = match?.[2];
+        module = tagModule ?? module;
+        const name = match?.[3];
+        if (!match) {
+            throw new Error(`Internal error: Invalid name or short tag ${nameOrShortTag}`);
+        }
+        if (!name) {
+            throw new Error(`Internal error: Invalid name or short tag ${nameOrShortTag}, no name specified`);
+        }
+        if (name.includes(':')) {
+            throw new Error(`Internal error: Invalid name or short tag ${nameOrShortTag}, name ${name} includes invalid characters`);
+        }
+        return new Tag(module, type, name);
+    }
+    static get unsafe() {
+        return __unsafe_Tag;
+    }
+    //
+    static resolve(self, tree) {
+        const module = tree.modules[self.module];
+        if (!module) {
+            throw new Error(`Module ${self.module} is not an option to resolve the Tag`);
+        }
+        return this.resolveFrom(self, module.schema);
+    }
+    static resolveFrom(self, module) {
+        if (self.module !== module.name) {
+            throw new Error(`Schema with tag ${self.full} does not belong to module ${module.name}`);
+        }
+        if (self.type === 'constants')
+            return module.constants;
+        if (self.type === 'constants.enum')
+            return module.constants.enums[self.name];
+        if (self.type === 'constants.value')
+            return module.constants.values[self.name];
+        if (self.type === 'externals')
+            return module.externals;
+        if (self.type === 'bucket')
+            return module.buckets[self.name];
+        if (self.type === 'message')
+            return module.messages[self.name];
+        if (self.type === 'job')
+            return module.jobs[self.name];
+        if (self.type === 'resource')
+            return module.resources[self.name];
+        if (self.type === 'machine')
+            return module.machines[self.name];
+        if (self.type === 'controller')
+            return module.controllers[self.name];
+        throw new Error(`Schema with tag ${self.full} not found on module ${module.name}`);
+    }
+    static resolveExternal(self, externals) {
+        if (self.type === 'constants.enum') {
+            const enums = externals.enums;
+            return enums[self.short];
+        }
+        if (self.type === 'constants.value') {
+            const values = externals.values;
+            return values[self.short];
+        }
+        if (self.type === 'bucket') {
+            const buckets = externals.buckets;
+            return buckets[self.short];
+        }
+        if (self.type === 'message') {
+            const messages = externals.messages;
+            return messages[self.short];
+        }
+        if (self.type === 'job') {
+            const jobs = externals.jobs;
+            return jobs[self.short];
+        }
+        if (self.type === 'machine') {
+            const machines = externals.machines;
+            return machines[self.short];
+        }
+        const module = externals.module;
+        throw new Error(`External tag ${self.full} not found on module ${module}`);
+    }
+    static element(self, trx) {
+        const module = trx_node_1.TrxNode.getModule(trx);
+        if (self.module !== module.name) {
+            throw new Error(`Element with tag ${self.full} does not belong to module ${module.name}`);
+        }
+        if (self.type === 'constants')
+            return module.schema.constants;
+        if (self.type === 'constants.enum')
+            return module.schema.constants.enums[self.name];
+        if (self.type === 'constants.value')
+            return module.schema.constants.values[self.name];
+        if (self.type === 'externals')
+            return module.schema.externals;
+        if (self.type === 'bucket')
+            return module.buckets[self.name];
+        if (self.type === 'message')
+            return module.messages[self.name];
+        if (self.type === 'job')
+            return module.jobs[self.name];
+        if (self.type === 'resource')
+            return module.resources[self.name];
+        if (self.type === 'machine')
+            return module.machines[self.name];
+        if (self.type === 'controller')
+            return module.controllers[self.name];
+        throw new Error(`Element with tag ${self.full} not found on module ${module.name}`);
+    }
+    static matches(self, other) {
+        if (self.module !== other.module)
+            return false;
+        if (self.type !== other.type)
+            return false;
+        if (self.name !== other.name)
+            return false;
+        return true;
+    }
+    static isSameNodeAs(self, other) {
+        if (self.module !== other.module)
+            return false;
+        if (self.type === 'constants') {
+            if (!other.type.startsWith('constants'))
+                return false;
+            return true;
+        }
+        if (other.type === 'constants') {
+            if (!self.type.startsWith('constants'))
+                return false;
+            return true;
+        }
+        if (self.type !== other.type)
+            return false;
+        if (self.name !== other.name)
+            return false;
+        return true;
+    }
+}
+exports.Tag = Tag;
+class __unsafe_Tag {
+    static from(tag) {
+        const match = tag.match(/(\w+)::([\w.]+):(\w*)/);
+        const module = match?.[1];
+        const type = match?.[2];
+        const name = match?.[3];
+        if (!match
+            || !module
+            || !type
+            || !name
+            || module.includes(':')
+            || type.includes(':')
+            || name.includes(':')) {
+            return undefined;
+        }
+        // TODO: validate type?
+        return new Tag(module, type, name);
+    }
+    static fromShort(type, shortTag) {
+        const match = shortTag.match(/(\w+)::(\w*)/);
+        const module = match?.[1];
+        const name = match?.[2];
+        if (!match
+            || !module
+            || !name
+            || module.includes(':')
+            || name.includes(':')) {
+            return undefined;
+        }
+        return new Tag(module, type, name);
+    }
+    static fromNameOrShort(module, type, nameOrShortTag) {
+        const match = nameOrShortTag.match(/((\w+)::)?(\w*)/);
+        const tagModule = match?.[1];
+        module = tagModule ?? module;
+        const name = match?.[3];
+        if (!match
+            || !name
+            || name.includes(':')) {
+            return undefined;
+        }
+        return new Tag(module, type, name);
     }
 }
-exports.$Tag = $Tag;
+exports.__unsafe_Tag = __unsafe_Tag;
 /**
- * A reference for an element, declared from another element.
+ * A link between two elements.
  *
  * @category Engine
  */
-class $Dependency {
-    /**
-     * @param fromModule Name of module which uses this dependency
-     * @param type Type of referenced element
-     * @param name Name of referenced element
-     * @param soft True if this doesn't affect build order
-     */
-    constructor(fromModule, type, name, soft = false) {
-        this.type = type;
-        this.soft = soft;
-        const parsed = $Tag.parseOrFail(name);
-        this.name = parsed.name;
-        if (parsed.module) {
-            this.module = parsed.module;
-        }
-        else {
-            this.module = fromModule;
-        }
-        this.tag = `${this.module}::${this.type}:${this.name}`;
-        if (this.module === fromModule) {
-            this.refName = this.name;
-        }
-        else {
-            this.refName = `${this.module}::${this.name}`;
-        }
-    }
-    /**
-     * Return the type name (UpperCamel) of the element
-     * referenced by a dependency.
-     *
-     * @param dep A `$Dependency` instance
-     * @param fromModule Name of dependant module
-     * @returns The type name of the dependency
-     */
-    static typeName(dep, fromModule) {
-        if (dep.module !== fromModule) {
-            const moduleHigh = name_helpers_1.NameHelpers.nameLowToHigh(dep.module);
-            // WARN: this might break non-regular plural block names in the future
-            const el_t = dep.type + 's';
-            return `${moduleHigh}Module['${el_t}']['${dep.name}']`;
-        }
-        else {
-            return name_helpers_1.NameHelpers
-                .names({ $t: dep.type, name: dep.name })
-                .type;
-        }
-    }
-    static resolve(module, dep) {
-        if (dep.type === 'constants')
-            return module.constants;
-        if (dep.type === 'externals')
-            return module.externals;
-        if (dep.type === 'bucket')
-            return module.buckets[dep.name];
-        if (dep.type === 'message')
-            return module.messages[dep.name];
-        if (dep.type === 'job')
-            return module.jobs[dep.name];
-        if (dep.type === 'resource')
-            return module.resources[dep.name];
-        if (dep.type === 'machine')
-            return module.machines[dep.name];
-        if (dep.type === 'controller')
-            return module.controllers[dep.name];
+class Dependency {
+    constructor(fromModule, tag, options) {
+        this.fromModule = fromModule;
+        this.tag = tag;
+        this.external = tag.module !== fromModule;
+        this.build = options?.build || false;
+        this.compile = options?.compile || false;
+        this.runtime = options?.runtime || false;
     }
 }
-exports.$Dependency = $Dependency;
+exports.Dependency = Dependency;
+// Compiler
 /**
  * A element builder, along with metadata required for building it.
  *
@@ -148,10 +277,7 @@ exports.$Dependency = $Dependency;
  */
 class BuilderNode {
     constructor($) {
-        this.module = $.module;
-        this.type = $.type;
-        this.name = $.name;
-        this.tag = `${this.module}::${this.type}:${this.name}`;
+        this.tag = $.tag;
         this.isInline = $.isInline;
         this.filepath = $.filepath;
         this.dependencies = $.dependencies;