@lakutata/core 1.0.59 → 3.0.0-beta.0

package/dist/esm/lib/base/internal/MemberDeclarations.js

@@ -0,0 +1,40 @@
+import { objectParentConstructors } from '@lakutata/utils/ObjectParentConstructors';
+/**
+ * The declaration of a property removed by a class: a subclass declaring the property otherwise (an injection
+ * declared again as a configurable property, or a configurable property declared again as an injection)
+ */
+export const REMOVED = Symbol('REMOVED');
+/**
+ * The declarations of the properties of a class only (created when missing)
+ * @param metadataKey
+ * @param target
+ */
+export function ownDeclarations(metadataKey, target) {
+    let declarations = Reflect.getOwnMetadata(metadataKey, target);
+    if (!declarations) {
+        declarations = new Map();
+        Reflect.defineMetadata(metadataKey, declarations, target);
+    }
+    return declarations;
+}
+/**
+ * The declarations of the properties of a class and of its parents: from the farthest parent to the class, the closest
+ * declaration of a property wins, a removal by a closer class removes it
+ * @param metadataKey
+ * @param target
+ */
+export function mergedDeclarations(metadataKey, target) {
+    const merged = new Map();
+    for (const constructor of [...objectParentConstructors(target).reverse(), target]) {
+        const own = Reflect.getOwnMetadata(metadataKey, constructor);
+        own?.forEach((declaration, propertyKey) => {
+            if (declaration === REMOVED) {
+                merged.delete(propertyKey);
+            }
+            else {
+                merged.set(propertyKey, declaration);
+            }
+        });
+    }
+    return merged;
+}

package/dist/esm/lib/base/internal/MethodAssistantFunction.js

@@ -0,0 +1,106 @@
+import { isAsyncFunction } from 'node:util/types';
+import { InvalidAssistantFunctionTypeException } from '../../../exceptions/InvalidAssistantFunctionTypeException.js';
+import { As } from '@lakutata/utils/As';
+const ASST_BEFORE_FUNC_SET = Symbol('ASST.BEFORE.FUNC.SET');
+const ASST_AFTER_FUNC_SET = Symbol('ASST.AFTER.FUNC.SET');
+const ASST_MODIFIED = Symbol('ASST.MODIFIED');
+/**
+ * Register a function which will run before target method
+ * @param target
+ * @param propertyKey
+ * @param descriptor
+ * @param beforeFunction
+ * @constructor
+ */
+export function registerBeforeFunction(target, propertyKey, descriptor, beforeFunction) {
+    descriptor.value = registerAssistantFunctionToMethod(target, propertyKey, applicabilityCheck(descriptor.value, beforeFunction), {
+        before: beforeFunction
+    });
+    return descriptor;
+}
+/**
+ * Register a function which will run after target method
+ * @param target
+ * @param propertyKey
+ * @param descriptor
+ * @param afterFunction
+ * @constructor
+ */
+export function registerAfterFunction(target, propertyKey, descriptor, afterFunction) {
+    descriptor.value = registerAssistantFunctionToMethod(target, propertyKey, applicabilityCheck(descriptor.value, afterFunction), {
+        after: afterFunction
+    });
+    return descriptor;
+}
+/**
+ * Register assistant function to method
+ * @param target
+ * @param propertyKey
+ * @param originalMethod
+ * @param assistantFunction
+ */
+function registerAssistantFunctionToMethod(target, propertyKey, originalMethod, assistantFunction) {
+    const beforeFunctionSet = Reflect.getOwnMetadata(ASST_BEFORE_FUNC_SET, target, propertyKey) || new Set();
+    const afterFunctionSet = Reflect.getOwnMetadata(ASST_AFTER_FUNC_SET, target, propertyKey) || new Set();
+    if (assistantFunction.before) {
+        beforeFunctionSet.add(assistantFunction.before);
+        Reflect.defineMetadata(ASST_BEFORE_FUNC_SET, beforeFunctionSet, target, propertyKey);
+    }
+    if (assistantFunction.after) {
+        afterFunctionSet.add(assistantFunction.after);
+        Reflect.defineMetadata(ASST_AFTER_FUNC_SET, afterFunctionSet, target, propertyKey);
+    }
+    if (Reflect.hasOwnMetadata(ASST_MODIFIED, target, propertyKey))
+        return As(originalMethod);
+    Reflect.defineMetadata(ASST_MODIFIED, true, target, propertyKey);
+    let modifiedMethod;
+    if (isAsyncFunction(originalMethod)) {
+        modifiedMethod = async function (...args) {
+            const beforeFunctionSet = Reflect.getOwnMetadata(ASST_BEFORE_FUNC_SET, target, propertyKey) || new Set();
+            const afterFunctionSet = Reflect.getOwnMetadata(ASST_AFTER_FUNC_SET, target, propertyKey) || new Set();
+            for (const beforeFunc of beforeFunctionSet) {
+                const beforeFuncResult = await beforeFunc.call(this, ...args);
+                if (beforeFuncResult !== undefined)
+                    args = beforeFuncResult;
+            }
+            let result = await originalMethod.call(this, ...args);
+            for (const afterFunc of afterFunctionSet) {
+                const afterFuncResult = await afterFunc.call(this, result);
+                if (afterFuncResult !== undefined)
+                    result = afterFuncResult;
+            }
+            return result;
+        };
+    }
+    else {
+        modifiedMethod = function (...args) {
+            const beforeFunctionSet = Reflect.getOwnMetadata(ASST_BEFORE_FUNC_SET, target, propertyKey) || new Set();
+            const afterFunctionSet = Reflect.getOwnMetadata(ASST_AFTER_FUNC_SET, target, propertyKey) || new Set();
+            for (const beforeFunc of beforeFunctionSet) {
+                const beforeFuncResult = As(beforeFunc.call(this, ...args));
+                if (beforeFuncResult !== undefined)
+                    args = beforeFuncResult;
+            }
+            let result = originalMethod.call(this, ...args);
+            for (const afterFunc of afterFunctionSet) {
+                const afterFuncResult = As(afterFunc.call(this, result));
+                if (afterFuncResult !== undefined)
+                    result = afterFuncResult;
+            }
+            return result;
+        };
+    }
+    return modifiedMethod;
+}
+/**
+ * Whether assistant function applicable to target method
+ */
+function applicabilityCheck(targetMethod, assistantFunction) {
+    if (!targetMethod)
+        throw new InvalidAssistantFunctionTypeException('Target method is undefined');
+    if (isAsyncFunction(targetMethod))
+        return targetMethod;
+    if (!isAsyncFunction(assistantFunction))
+        return targetMethod;
+    throw new InvalidAssistantFunctionTypeException('Assistant function must not be async function when target method is not async function');
+}

package/dist/esm/lib/base/internal/ModuleConfigLoader.js

@@ -0,0 +1,109 @@
+import { OBJECT_ID } from '../../../options/LoadObjectOptions.js';
+import { BaseObject } from '../BaseObject.js';
+import { OverridableObjectTargetConfigNotFoundException } from '../../../exceptions/di/OverridableObjectTargetConfigNotFoundException.js';
+import { As } from '@lakutata/utils/As';
+import { getObjectType, ObjectType } from './ObjectType.js';
+import { InvalidObjectTypeException } from '../../../exceptions/InvalidObjectTypeException.js';
+import { arrayToSet } from '@lakutata/utils/ArrayToSet';
+import { setToArray } from '@lakutata/utils/SetToArray';
+/**
+ * Module configurations loader
+ */
+export class ModuleConfigLoader {
+    /**
+     * Constructor
+     * @param module
+     * @param moduleOptions
+     * @param presetLoadOptions
+     */
+    constructor(module, moduleOptions, presetLoadOptions = []) {
+        this.$presetLoadOptionsSet = new Set();
+        this.$loadOptions = [];
+        this.$bootstrap = [];
+        this.$module = module;
+        this.$presetLoadOptionsSet = arrayToSet(presetLoadOptions);
+        this.$bootstrap = moduleOptions.bootstrap ? moduleOptions.bootstrap : [];
+        //Process anonymous objects
+        moduleOptions.objects?.anonymous?.forEach((anonymousObject) => this.$loadOptions.push(anonymousObject));
+        //Process named objects
+        if (moduleOptions.objects && moduleOptions.objects.named) {
+            const namedObjects = moduleOptions.objects.named;
+            Object.keys(namedObjects).forEach((id) => this.$loadOptions.push({
+                ...namedObjects[id],
+                [OBJECT_ID]: id
+            }));
+        }
+        //Process component objects
+        this.processOverridableNamedObjectOptions(ObjectType.Component, moduleOptions.components);
+        //Process provider objects
+        this.processOverridableNamedObjectOptions(ObjectType.Provider, moduleOptions.providers);
+    }
+    /**
+     * Validate constructor's object type
+     * @param expectObjectType
+     * @param target
+     * @param id
+     * @protected
+     */
+    validateObjectType(expectObjectType, target, id) {
+        const objectType = getObjectType(target);
+        if (objectType === expectObjectType)
+            return target;
+        //The objects declared in the wrong configuration name the configuration they belong to
+        const expected = expectObjectType.toLowerCase();
+        const actual = objectType.toLowerCase();
+        const hint = objectType === ObjectType.Component || objectType === ObjectType.Provider
+            ? `, declare it in the ${actual}s configuration`
+            //The modules are objects: objects: {named: {<id>: {class: <Module>}}}
+            : objectType === ObjectType.Module ? ', declare it in the objects configuration (objects.named)' : '';
+        throw new InvalidObjectTypeException('{0} configuration only accepts object declarations of {1} types: "{2}" ({3}) is a {4}{5}', [expectObjectType, expected, id ?? target.name, target.name, actual, hint]);
+    }
+    /**
+     * Process overridable named object options
+     * @param objectType
+     * @param options
+     * @protected
+     */
+    processOverridableNamedObjectOptions(objectType, options) {
+        if (!options)
+            return;
+        Object.keys(options).forEach((id) => {
+            const overridableObjectOptions = options[id];
+            overridableObjectOptions[OBJECT_ID] = id;
+            if (overridableObjectOptions.class) {
+                overridableObjectOptions.class = this.validateObjectType(objectType, overridableObjectOptions.class, id);
+                //An object declared with its class replaces the preset object of the same name
+                for (const loadOptions of this.$presetLoadOptionsSet) {
+                    if (typeof loadOptions === 'string' || loadOptions instanceof BaseObject)
+                        continue;
+                    if (id === loadOptions[OBJECT_ID])
+                        this.$presetLoadOptionsSet.delete(loadOptions);
+                }
+                return this.$loadOptions.push(As(overridableObjectOptions)) ? void (0) : void (0);
+            }
+            for (const loadOptions of this.$presetLoadOptionsSet) {
+                if (typeof loadOptions === 'string')
+                    continue;
+                if (loadOptions instanceof BaseObject)
+                    continue;
+                if (overridableObjectOptions[OBJECT_ID] === loadOptions[OBJECT_ID]) {
+                    this.$loadOptions.push(Object.assign({}, loadOptions, overridableObjectOptions));
+                    return this.$presetLoadOptionsSet.delete(loadOptions) ? void (0) : void (0);
+                }
+            }
+            throw new OverridableObjectTargetConfigNotFoundException('No applicable configuration target found');
+        });
+    }
+    /**
+     * Load options for container.load()
+     */
+    get loadOptions() {
+        return [...this.$loadOptions, ...setToArray(this.$presetLoadOptionsSet)];
+    }
+    /**
+     * Load bootstrap for module
+     */
+    get bootstrap() {
+        return this.$bootstrap;
+    }
+}

package/dist/esm/lib/base/internal/ModuleInitialization.js

@@ -0,0 +1,5 @@
+/**
+ * The method of a module giving its initialization (its objects loaded, its bootstrap run): the container resolving the
+ * module for an object outside it waits for it
+ */
+export const MODULE_INITIALIZATION = Symbol('LAKUTATA.MODULE.INITIALIZATION');

package/dist/esm/lib/base/internal/ObjectConfiguration.js

@@ -0,0 +1,36 @@
+import { DI_TARGET_CONSTRUCTOR_CONFIGURABLE_PROPERTIES } from '../../../constants/DIMetadataKey.js';
+import { DTO } from '../../dto/DTO.js';
+import { objectConstructor } from '@lakutata/utils/ObjectConstructor';
+import { mergedDeclarations, ownDeclarations, REMOVED } from './MemberDeclarations.js';
+/**
+ * Add object configurable property to Set
+ * @param target
+ * @param propertyKey
+ * @param schema
+ * @param fn
+ * @constructor
+ */
+export function setObjectConfigurableProperty(target, propertyKey, schema = DTO.Any(), fn) {
+    ownDeclarations(DI_TARGET_CONSTRUCTOR_CONFIGURABLE_PROPERTIES, objectConstructor(target)).set(propertyKey, {
+        schema: schema,
+        fn: fn ? fn : (value) => value
+    });
+}
+/**
+ * Remove the configurable property of the parents of a class: the class declares the property otherwise
+ * @param target
+ * @param propertyKey
+ * @constructor
+ */
+export function removeObjectConfigurableProperty(target, propertyKey) {
+    ownDeclarations(DI_TARGET_CONSTRUCTOR_CONFIGURABLE_PROPERTIES, objectConstructor(target)).set(propertyKey, REMOVED);
+}
+/**
+ * Get object configurable properties by its prototype: the ones of the class and of its parents, the closest
+ * declaration of a property winning
+ * @param target
+ * @constructor
+ */
+export function getObjectConfigurableProperties(target) {
+    return mergedDeclarations(DI_TARGET_CONSTRUCTOR_CONFIGURABLE_PROPERTIES, objectConstructor(target));
+}

package/dist/esm/lib/base/internal/ObjectContainer.js

@@ -0,0 +1,19 @@
+import { DI_TARGET_CONTAINER } from '../../../constants/DIMetadataKey.js';
+/**
+ * Set container getter
+ * @param target
+ * @param container
+ * @constructor
+ */
+export function setObjectContainerGetter(target, container) {
+    Reflect.defineMetadata(DI_TARGET_CONTAINER, () => container, target);
+}
+/**
+ * Get container via class prototype
+ * @param target
+ * @constructor
+ */
+export function getObjectContainer(target) {
+    const containerGetter = Reflect.getOwnMetadata(DI_TARGET_CONTAINER, target);
+    return containerGetter();
+}

package/dist/esm/lib/base/internal/ObjectInjection.js

@@ -0,0 +1,53 @@
+import { DI_TARGET_CONSTRUCTOR_AUTOLOAD, DI_TARGET_CONSTRUCTOR_INJECTS } from '../../../constants/DIMetadataKey.js';
+import { objectConstructor } from '@lakutata/utils/ObjectConstructor';
+import { mergedDeclarations, ownDeclarations, REMOVED } from './MemberDeclarations.js';
+/**
+ * Set object inject item
+ * @param target
+ * @param propertyKey
+ * @param name
+ * @param transform
+ * @constructor
+ */
+export function setObjectInjectItem(target, propertyKey, name, transform) {
+    ownDeclarations(DI_TARGET_CONSTRUCTOR_INJECTS, objectConstructor(target)).set(propertyKey, {
+        name: name,
+        transform: transform
+    });
+}
+/**
+ * Remove the injection of a property of the parents of a class: the class declares the property otherwise
+ * @param target
+ * @param propertyKey
+ * @constructor
+ */
+export function removeObjectInjectItem(target, propertyKey) {
+    ownDeclarations(DI_TARGET_CONSTRUCTOR_INJECTS, objectConstructor(target)).set(propertyKey, REMOVED);
+}
+/**
+ * Get object inject items by its prototype: the ones of the class and of its parents, the closest declaration of a
+ * property winning
+ * @param target
+ * @constructor
+ */
+export function getObjectInjectItemsByPrototype(target) {
+    return mergedDeclarations(DI_TARGET_CONSTRUCTOR_INJECTS, objectConstructor(target));
+}
+/**
+ * Mark object as autoload
+ * @param target
+ * @constructor
+ */
+export function markObjectAsAutoload(target) {
+    if (!Reflect.hasOwnMetadata(DI_TARGET_CONSTRUCTOR_AUTOLOAD, target))
+        Reflect.defineMetadata(DI_TARGET_CONSTRUCTOR_AUTOLOAD, true, target);
+    return target;
+}
+/**
+ * Whether an object is autoload object or not
+ * @param target
+ * @constructor
+ */
+export function getObjectIsAutoload(target) {
+    return !!Reflect.getOwnMetadata(DI_TARGET_CONSTRUCTOR_AUTOLOAD, target);
+}

package/dist/esm/lib/base/internal/ObjectOptionsCheck.js

@@ -0,0 +1,67 @@
+import { OBJECT_ID } from '../../../options/LoadObjectOptions.js';
+import { getObjectConfigurableProperties } from './ObjectConfiguration.js';
+import { DTO } from '../../dto/DTO.js';
+import { InvalidValueException } from '../../../exceptions/dto/InvalidValueException.js';
+import { InvalidObjectOptionsException } from '../../../exceptions/di/InvalidObjectOptionsException.js';
+import { throwWarning } from '../../foundation/ThrowWarning.js';
+import { As } from '@lakutata/utils/As';
+/**
+ * The options of the declarations which are not options of the object
+ */
+const DECLARATION_OPTIONS = new Set(['class', 'id']);
+/**
+ * Check the options of the objects declared in a module, before any of them is created (an object never created is
+ * checked too): an invalid value of a configurable property is an error, an option which is not a configurable property
+ * and which the class does not accept (see BaseObject.acceptsOption()) is a warning. The values are validated as the
+ * objects validate them, without their transforms. The options not given are not checked (they may be given when the
+ * object is got), nor the properties validated asynchronously (by external rules), which the object validates
+ * @param loadOptions
+ * @constructor
+ */
+export function checkObjectOptions(loadOptions) {
+    const errors = [];
+    const warnings = [];
+    for (const declaration of loadOptions) {
+        if (typeof declaration !== 'object' || !declaration || typeof declaration.class !== 'function')
+            continue;
+        const target = declaration.class;
+        const id = declaration[OBJECT_ID];
+        const object = typeof id === 'string' ? `"${id}" (${target.name})` : target.name;
+        const properties = getObjectConfigurableProperties(As(target.prototype));
+        for (const name of Object.keys(declaration)) {
+            const value = declaration[name];
+            if (DECLARATION_OPTIONS.has(name) || value === undefined)
+                continue;
+            const property = properties.get(name);
+            if (!property) {
+                if (!target.acceptsOption(name, value))
+                    warnings.push(unknownOptionMessage(object, name, properties));
+                continue;
+            }
+            try {
+                DTO.validate(value, property.schema, { targetName: name });
+            }
+            catch (e) {
+                //Not an invalid value: a schema with external rules, which only the asynchronous validation runs
+                if (!(e instanceof InvalidValueException))
+                    continue;
+                errors.push(`The option "${name}" of ${object} is invalid: ${e.message}`);
+            }
+        }
+    }
+    warnings.forEach((warning) => throwWarning(warning));
+    if (errors.length)
+        throw new InvalidObjectOptionsException(errors.join('\n'));
+}
+/**
+ * The warning of an option which is not a configurable property
+ * @param object
+ * @param name
+ * @param properties
+ * @constructor
+ */
+function unknownOptionMessage(object, name, properties) {
+    const names = [...properties.keys()].filter((key) => typeof key === 'string').sort();
+    const hint = names.length ? `its configurable properties: ${names.join(', ')}` : 'it has no configurable property';
+    return `The option "${name}" of ${object} is not a configurable property, it is ignored (${hint})`;
+}

package/dist/esm/lib/base/internal/ObjectStartup.js

@@ -0,0 +1,69 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { DevNull } from '@lakutata/utils/DevNull';
+/**
+ * The objects whose startup the current asynchronous call chain belongs to: the objects they get (directly, or through
+ * the objects they create) are given to them without waiting for their own startup
+ */
+const startupFrames = new AsyncLocalStorage();
+/**
+ * The startup of each object (the last one, for a reloaded object)
+ */
+const startups = new WeakMap();
+/**
+ * Run the startup of an object, after its initialization: the objects getting it wait for its startup, except the
+ * call chain of its startup itself, which gets it at once (initialized, not started yet)
+ * @param object The object.
+ * @param startup Its startup.
+ * @returns The startup, its failure handled (it is delivered to the objects getting the object).
+ * @internal
+ */
+export function runObjectStartup(object, startup) {
+    const frame = { object: object, active: true };
+    const running = startupFrames.run([...(startupFrames.getStore() ?? []), frame], async () => {
+        try {
+            await startup();
+        }
+        finally {
+            //The work it began (servers, timers…) keeps the call chain: it no longer skips the wait once started
+            frame.active = false;
+        }
+    });
+    const record = { promise: running, ended: false };
+    running.catch(DevNull).finally(() => record.ended = true);
+    startups.set(object, record);
+    return running;
+}
+/**
+ * Tell whether the current call chain belongs to the startup of an object
+ * @param object The object.
+ * @returns true within its startup.
+ * @internal
+ */
+export function isInObjectStartup(object) {
+    return !!startupFrames.getStore()?.some((frame) => frame.active && frame.object === object);
+}
+/**
+ * Wait for the startup of an object given to a requester (at once without startup, or within its startup)
+ * @param object The object.
+ * @returns Resolves once it started, rejects with the error of its startup.
+ * @internal
+ */
+export async function waitForObjectStartup(object) {
+    const startup = startups.get(object);
+    if (!startup || isInObjectStartup(object))
+        return;
+    await startup.promise;
+}
+/**
+ * The end of the startup of an object, its failure ignored (its teardown waits for it): none when it has no startup
+ * running, or within its startup, so that its teardown goes on in the same turn
+ * @param object The object.
+ * @returns Resolves once its startup ended; undefined when there is nothing to wait for.
+ * @internal
+ */
+export function waitForObjectStartupEnd(object) {
+    const startup = startups.get(object);
+    if (!startup || startup.ended || isInObjectStartup(object))
+        return undefined;
+    return startup.promise.catch(DevNull);
+}

package/dist/esm/lib/base/internal/ObjectType.js

@@ -0,0 +1,68 @@
+import { objectParentConstructors } from '@lakutata/utils/ObjectParentConstructors';
+import { isSubclassOf } from '@lakutata/utils/IsSubclassOf';
+/**
+ * Internal unique symbol
+ */
+const OBJECT_TYPE = Symbol('OBJECT.TYPE');
+/**
+ * Object Type
+ */
+export var ObjectType;
+(function (ObjectType) {
+    ObjectType["Unknown"] = "Unknown";
+    ObjectType["Object"] = "Object";
+    ObjectType["Provider"] = "Provider";
+    ObjectType["Component"] = "Component";
+    ObjectType["Module"] = "Module";
+})(ObjectType || (ObjectType = {}));
+/**
+ * BaseObject, registered by its module once it is defined: this module does not import it, BaseObject is decorated by
+ * DefineObjectType while it is defined (an import would be a cycle, which fails when the first module loaded imports
+ * BaseObject through this module)
+ */
+let baseObjectConstructor;
+/**
+ * Register BaseObject
+ * @param constructor
+ * @constructor
+ */
+export function registerBaseObject(constructor) {
+    baseObjectConstructor = constructor;
+}
+/**
+ * Class Decorator
+ * @param type
+ * @constructor
+ */
+export function DefineObjectType(type) {
+    return (target) => setObjectType(target, type);
+}
+/**
+ * Set object type
+ * @param target
+ * @param type
+ * @constructor
+ */
+export function setObjectType(target, type) {
+    //BaseObject itself is not its own subclass: it is not registered yet when it is decorated
+    Reflect.defineMetadata(OBJECT_TYPE, baseObjectConstructor && isSubclassOf(target, baseObjectConstructor) ? type : ObjectType.Unknown, target);
+    return target;
+}
+/**
+ * Get object type
+ * @param target
+ * @constructor
+ */
+export function getObjectType(target) {
+    if (Reflect.hasOwnMetadata(OBJECT_TYPE, target))
+        return Reflect.getOwnMetadata(OBJECT_TYPE, target);
+    let objectType = ObjectType.Unknown;
+    for (const parentConstructor of objectParentConstructors(target)) {
+        if (Reflect.hasOwnMetadata(OBJECT_TYPE, parentConstructor)) {
+            objectType = Reflect.getOwnMetadata(OBJECT_TYPE, parentConstructor);
+            break;
+        }
+    }
+    setObjectType(target, objectType);
+    return getObjectType(target);
+}

package/dist/esm/lib/core/Alias.js

@@ -0,0 +1,93 @@
+import path from 'path';
+import { InvalidAliasNameException } from '../../exceptions/alias/InvalidAliasNameException.js';
+import { AliasExistsException } from '../../exceptions/alias/AliasExistsException.js';
+import { AliasNotFoundException } from '../../exceptions/alias/AliasNotFoundException.js';
+export class Alias {
+    /**
+     * Constructor
+     */
+    constructor() {
+        this.aliasNameRegExp = /^@[a-zA-Z0-9]+$/;
+        this.aliasMap = new Map();
+        const oldPathResolve = path.resolve;
+        path.resolve = (...paths) => {
+            const resolvedPaths = paths.map((value) => this.resolve(value));
+            return oldPathResolve(...resolvedPaths);
+        };
+    }
+    /**
+     * Init alias manager, must init it before application instance init
+     */
+    static init() {
+        const instance = new this();
+        Reflect.defineMetadata(this, instance, this);
+    }
+    /**
+     * Get alias manager instance
+     */
+    static getAliasInstance() {
+        if (!Reflect.hasOwnMetadata(this, this))
+            this.init();
+        return Reflect.getMetadata(this, this);
+    }
+    set(aliasName, aliasPath, override = false) {
+        if (!this.aliasNameRegExp.test(aliasName))
+            throw new InvalidAliasNameException('The alias should start with \'@\' and only contain characters a-z|A-Z|0-9. The current alias \'{aliasName}\' does not comply with this rule.', { aliasName });
+        if (this.aliasMap.has(aliasName) && !override)
+            throw new AliasExistsException('The alias \'{aliasName}\' already exists.', { aliasName });
+        this.aliasMap.set(aliasName, aliasPath);
+    }
+    /**
+     * Resolve alias
+     * @param aliasName
+     */
+    get(aliasName) {
+        if (!this.aliasNameRegExp.test(aliasName))
+            throw new InvalidAliasNameException('The alias should start with \'@\' and only contain characters a-z|A-Z|0-9. The current alias \'{aliasName}\' does not comply with this rule.', { aliasName });
+        if (!this.aliasMap.has(aliasName))
+            throw new AliasNotFoundException('The alias \'{aliasName}\' not found.', { aliasName });
+        const aliasPath = this.aliasMap.get(aliasName);
+        return this.resolve(aliasPath);
+    }
+    /**
+     * Whether an alias exists
+     * @param aliasName
+     */
+    has(aliasName) {
+        if (!this.aliasNameRegExp.test(aliasName))
+            throw new InvalidAliasNameException('The alias should start with \'@\' and only contain characters a-z|A-Z|0-9. The current alias \'{aliasName}\' does not comply with this rule.', { aliasName });
+        return this.aliasMap.has(aliasName);
+    }
+    /**
+     * Resolve string and replace alias name to alias value inside the string
+     * @param containAliasPath
+     */
+    resolve(containAliasPath) {
+        let isContainsAlias = true;
+        const aliases = [];
+        this.aliasMap.forEach((aliasPath, aliasName) => aliases.push({
+            name: aliasName,
+            path: aliasPath
+        }));
+        aliases.sort((a, b) => a.name.length < b.name.length ? 1 : -1);
+        while (isContainsAlias) {
+            let _isContainsAlias = false;
+            aliases.forEach(({ name, path }) => {
+                if (containAliasPath.includes(name)) {
+                    _isContainsAlias = true;
+                    containAliasPath = containAliasPath.replace(name, path);
+                }
+            });
+            isContainsAlias = _isContainsAlias;
+        }
+        return path.normalize(containAliasPath);
+    }
+    /**
+     * List aliases
+     */
+    list() {
+        const aliasList = {};
+        this.aliasMap.forEach((aliasValue, aliasKey) => Reflect.set(aliasList, aliasKey, aliasValue));
+        return aliasList;
+    }
+}