@adaas/a-concept 0.1.24 → 0.1.25

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@adaas/a-concept",
-  "version": "0.1.24",
+  "version": "0.1.25",
   "description": "A-Concept is a framework to build new Applications within or outside the ADAAS ecosystem. This framework is designed to be modular structure regardless environment and program goal.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
+  "sideEffects": false,
   "nodemonConfig": {
     "ignore": [
       "**/*.test.ts",
@@ -23,16 +24,13 @@
     "test": "jest ",
     "start": "nodemon ./tests/example-usage.ts",
     "example:simple": "nodemon ./examples/simple/concept.ts",
-    "example:simple:trace": "node -r tsconfig-paths/register -r ts-node/register -r ./trace-require.js ./examples/simple/concept.ts",
     "example:http": "nodemon ./examples/simple-http-server/concept.ts",
     "example:entity": "nodemon ./examples/entity/concept.ts",
-    "example:http:trace": "node -r tsconfig-paths/register -r ts-node/register -r ./trace-require.js ./examples/simple-http-server/concept.ts",
     "publish": "npm run test && npm run build && git add . && git commit -m \"new version created :: $(cat package.json | grep version | head -1  | awk -F: '{ print $2 }'  | sed 's/[\",]//g')\" && npm version patch && npm publish --access public",
-    "preversion": "echo test",
     "version": "echo git add .",
     "postversion": "git push --no-verify && git push --tags --no-verify && echo \"\n======Version Pushed Successfully=====\n\" ",
     "echo-version": "echo $npm_package_version",
-    "build": "rm -rf ./dist && tsc --declaration --project tsconfig.build.json && tscpaths -p tsconfig.build.json -s ./ -o ./dist",
+    "build": "tsup --config tsup.config.ts",
     "test:simple": "nodemon ./examples/simple/concept.ts"
   },
   "repository": {
@@ -63,7 +61,8 @@
     "ts-jest": "^29.1.2",
     "ts-node": "^10.9.2",
     "tsconfig-paths": "^4.2.0",
-    "tscpaths": "^0.0.9"
+    "tscpaths": "^0.0.9",
+    "tsup": "^8.5.0"
   },
   "directories": {
     "doc": "docs",

package/src/global/A-Abstraction/A-Abstraction-Extend.decorator.ts

@@ -14,6 +14,7 @@ import { A_TYPES__ComponentMetaKey } from "@adaas/a-concept/global/A-Component/A
 import { A_TYPES__ConceptAbstraction } from "@adaas/a-concept/global/A-Concept/A-Concept.types";
 import { A_AbstractionError } from "./A-Abstraction.error";
 import { A_TypeGuards } from "@adaas/a-concept/helpers/A_TypeGuards.helper";
+import { A_CommonHelper } from "@adaas/a-concept/helpers/A_Common.helper";
 
 
 /**
@@ -42,7 +43,7 @@ export function A_Abstraction_Extend(
         descriptor: A_TYPES__AbstractionDecoratorDescriptor
     ) {
         // for error messages
-        const componentName = (target as any)?.constructor?.name || String(target) || 'UnknownComponent';
+        const componentName = A_CommonHelper.getComponentName(target)
 
         if (!name)
             throw new A_AbstractionError(

package/src/global/A-Context/A-Context.class.ts

@@ -37,6 +37,7 @@ import { A_Fragment } from "../A-Fragment/A-Fragment.class";
 import { A_TYPES__InjectableTargets } from "../A-Inject/A-Inject.types";
 import { A_TYPES__ConceptAbstraction } from "../A-Concept/A-Concept.types";
 import { A_TYPES__ConceptAbstractions } from "../A-Concept/A-Concept.constants";
+import { A_CommonHelper } from "@adaas/a-concept/helpers/A_Common.helper";
 
 
 
@@ -172,16 +173,18 @@ export class A_Context {
 
     ): A_Scope {
         // uses only for error messages
-        const componentName = (component as any)?.constructor?.name || String(component);
+        const componentName = A_CommonHelper.getComponentName(component);
 
         const instance = this.getInstance();
 
         if (!component) throw new A_ContextError(
             A_ContextError.InvalidRegisterParameterError,
             `Unable to register component. Component cannot be null or undefined.`);
+
         if (!scope) throw new A_ContextError(
             A_ContextError.InvalidRegisterParameterError,
             `Unable to register component. Scope cannot be null or undefined.`);
+
         if (!this.isAllowedToBeRegistered(component)) throw new A_ContextError(
             A_ContextError.NotAllowedForScopeAllocationError,
             `Component ${componentName} is not allowed for scope allocation.`);
@@ -191,6 +194,32 @@ export class A_Context {
         return scope;
     }
 
+    /**
+     * Deregister method allows to deregister a component from the context.
+     * 
+     * @param component - Component to deregister from the context.
+     */
+    static deregister(
+        /**
+         * Provide a component that needs to be deregistered from the context.
+         */
+        component: A_TYPES_ScopeDependentComponents,
+    ): void {
+        // uses only for error messages
+        const componentName = A_CommonHelper.getComponentName(component);   
+
+        const instance = this.getInstance();
+
+        if (!component) throw new A_ContextError(
+            A_ContextError.InvalidDeregisterParameterError,
+            `Unable to deregister component. Component cannot be null or undefined.`);
+
+        if (!instance._scopeStorage.has(component)) throw new A_ContextError(
+            A_ContextError.ComponentNotRegisteredError,
+            `Unable to deregister component. Component ${componentName} is not registered.`);
+
+        instance._scopeStorage.delete(component);
+    }
 
     /**
      * Allocate method instantiates a new scope for the given component and registers it in the context.
@@ -231,7 +260,7 @@ export class A_Context {
         importing?: Partial<A_TYPES__Scope_Init & A_TYPES__ScopeConfig> | A_Scope
     ): A_Scope {
         // uses only for error messages
-        const componentName = (component as any)?.constructor?.name || String(component);
+        const componentName = A_CommonHelper.getComponentName(component);
 
         // ---------------------------------------------------------------------
         // ----------------------Input Validation-------------------------------
@@ -266,6 +295,51 @@ export class A_Context {
         return newScope;
     }
 
+    /**
+     * Deallocate method removes the scope allocation for the given component from the context.
+     * 
+     * @param component 
+     * @returns 
+     */
+    static deallocate(
+        /**
+         * A Scope that needs to be deallocated.
+         */
+        scope: A_Scope,
+    )
+    static deallocate(
+        /**
+         * Provide a component that needs to have its scope deallocated.
+         */
+        component: A_TYPES__ScopeLinkedComponents,
+    )
+    static deallocate(
+        /**
+         * Provide a component that needs to have its scope deallocated.
+         */
+        param1: A_TYPES__ScopeLinkedComponents | A_Scope,
+    ) {
+        const instance = this.getInstance();
+
+
+        const scope = A_TypeGuards.isScopeInstance(param1)
+            ? param1
+            : instance._registry.get(param1);
+
+        if (!scope) return;
+
+        try {
+            const component = A_TypeGuards.isComponentInstance(param1)
+                ? param1
+                : this.issuer(scope);
+
+            instance._registry.delete(component);
+            instance._scopeIssuers.delete(scope);
+        } catch (error) {
+            return
+        }
+    }
+
 
 
     /**
@@ -338,7 +412,7 @@ export class A_Context {
     ): A_Meta<T> {
 
         // Get the component name for error messages
-        const componentName = (param1 as any)?.constructor?.name || String(param1);
+        const componentName = A_CommonHelper.getComponentName(param1);
         // Get the instance of the context
         const instance = this.getInstance();
 
@@ -581,7 +655,7 @@ export class A_Context {
         scope: A_Scope = this.scope(component)
     ): Array<A_TYPES__A_StageStep> {
         // name for error messages
-        const componentName = (component as any)?.constructor?.name || String(component);
+        const componentName = A_CommonHelper.getComponentName(component);
 
         // Input validation
         if (!component) throw new A_ContextError(A_ContextError.InvalidFeatureTemplateParameterError, `Unable to get feature template. Component cannot be null or undefined.`);
@@ -629,7 +703,7 @@ export class A_Context {
 
         const instance = this.getInstance();
         // name for error messages
-        const componentName = (component as any)?.constructor?.name || String(component);
+        const componentName = A_CommonHelper.getComponentName(component);
 
         // Input validation
         if (!component) throw new A_ContextError(A_ContextError.InvalidFeatureExtensionParameterError, `Unable to get feature template. Component cannot be null or undefined.`);
@@ -779,7 +853,7 @@ export class A_Context {
         component: A_TYPES__FeatureAvailableComponents,
     ): Array<A_TYPES__A_StageStep> {
         // name for error messages
-        const componentName = (component as any)?.constructor?.name || String(component);
+        const componentName = (A_CommonHelper.getComponentName(component));
 
         // Input validation
         if (!component) throw new A_ContextError(
@@ -822,7 +896,7 @@ export class A_Context {
     ): Array<A_TYPES__A_StageStep> {
         const instance = this.getInstance();
         // name for error messages
-        const componentName = (component as any)?.constructor?.name || String(component);
+        const componentName = A_CommonHelper.getComponentName(component);
 
         // Input validation
         if (!component) throw new A_ContextError(

package/src/global/A-Context/A-Context.error.ts

@@ -41,4 +41,8 @@ export class A_ContextError extends A_Error {
 
 
     static InvalidComponentParameterError = 'Invalid component provided';
+
+    static ComponentNotRegisteredError = 'Component not registered in the context';
+
+    static InvalidDeregisterParameterError = 'Invalid parameter provided to deregister component';
 }

package/src/global/A-Dependency/A-Dependency-Default.decorator.ts

@@ -0,0 +1,75 @@
+
+import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
+import { A_Meta } from "@adaas/a-concept/global/A-Meta/A-Meta.class";
+import { A_TYPES__ComponentMetaKey } from "@adaas/a-concept/global/A-Component/A-Component.constants";
+import { A_TYPES__ContainerMetaKey } from "@adaas/a-concept/global/A-Container/A-Container.constants";
+import { A_TypeGuards } from "@adaas/a-concept/helpers/A_TypeGuards.helper";
+import { A_TYPES__A_InjectDecorator_Meta, A_TYPES__InjectableTargets } from "../A-Inject/A-Inject.types";
+import { A_TYPES__A_Dependency_DefaultDecoratorReturn } from "./A-Dependency.types";
+import { A_DependencyError } from "./A-Dependency.error";
+import { A_CommonHelper } from "@adaas/a-concept/helpers/A_Common.helper";
+
+
+/**
+ * Should indicate which Default is required
+ */
+export function A_Dependency_Default(
+    /**
+     * Constructor Parameters that will be used to create the default instance
+     */
+    ...args: any[]
+): A_TYPES__A_Dependency_DefaultDecoratorReturn {
+
+
+    return function (
+        target: A_TYPES__InjectableTargets,
+        methodName: string | symbol | undefined,
+        parameterIndex: number
+    ) {
+        // for Error handling purposes
+        const componentName = A_CommonHelper.getComponentName(target)
+
+        if (!A_TypeGuards.isTargetAvailableForInjection(target)) {
+            throw new A_DependencyError(
+                A_DependencyError.InvalidDefaultTarget,
+                `A-Default cannot be used on the target of type ${typeof target} (${componentName})`
+            );
+        }
+
+        // determine the method name or 'constructor' for constructor injections
+        const method = methodName ? String(methodName) : 'constructor';
+        let metaKey;
+
+        switch (true) {
+            case A_TypeGuards.isComponentConstructor(target) || A_TypeGuards.isComponentInstance(target):
+                metaKey = A_TYPES__ComponentMetaKey.INJECTIONS;
+                break;
+
+            case A_TypeGuards.isContainerInstance(target):
+                metaKey = A_TYPES__ContainerMetaKey.INJECTIONS;
+                break;
+        }
+
+        // get existing meta or create a new one
+        const existedMeta = A_Context.meta(target).get(metaKey) || new A_Meta();
+        // get existing injections for the method or create a new array
+        const paramsArray: A_TYPES__A_InjectDecorator_Meta = existedMeta.get(method) || [];
+
+        // set the parameter injection info
+        paramsArray[parameterIndex] = {
+            ...(paramsArray[parameterIndex] || {}),
+            defaultArgs: args,
+            create: true
+        }
+        // save back the updated injections array
+        existedMeta.set(method, paramsArray);
+
+        // save back the updated meta info
+        A_Context
+            .meta(target)
+            .set(
+                metaKey,
+                existedMeta
+            );
+    }
+}

package/src/global/A-Dependency/A-Dependency-Load.decorator.ts

@@ -0,0 +1,80 @@
+
+import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
+import { A_Meta } from "@adaas/a-concept/global/A-Meta/A-Meta.class";
+import { A_TYPES__ComponentMetaKey } from "@adaas/a-concept/global/A-Component/A-Component.constants";
+import { A_TYPES__ContainerMetaKey } from "@adaas/a-concept/global/A-Container/A-Container.constants";
+import { A_TypeGuards } from "@adaas/a-concept/helpers/A_TypeGuards.helper";
+import { A_TYPES__A_InjectDecorator_Meta, A_TYPES__InjectableTargets } from "../A-Inject/A-Inject.types";
+import { A_TYPES__A_Dependency_LoadDecoratorReturn } from "./A-Dependency.types";
+import { A_DependencyError } from "./A-Dependency.error";
+import { A_CommonHelper } from "@adaas/a-concept/helpers/A_Common.helper";
+
+
+/**
+ * Should indicate which Load is required
+ */
+export function A_Dependency_Load(
+    /**
+     * Path to load the dependency from
+     */
+    path: string
+): A_TYPES__A_Dependency_LoadDecoratorReturn {
+
+    if (!path || typeof path !== 'string') {
+        throw new A_DependencyError(
+            A_DependencyError.InvalidLoadPath,
+            `A-Load decorator requires a valid path string to the dependency`
+        );
+    }
+
+    return function (
+        target: A_TYPES__InjectableTargets,
+        methodName: string | symbol | undefined,
+        parameterIndex: number
+    ) {
+        // for Error handling purposes
+        const componentName = A_CommonHelper.getComponentName(target);
+
+        if (!A_TypeGuards.isTargetAvailableForInjection(target)) {
+            throw new A_DependencyError(
+                A_DependencyError.InvalidLoadTarget,
+                `A-Load cannot be used on the target of type ${typeof target} (${componentName})`
+            );
+        }
+
+        // determine the method name or 'constructor' for constructor injections
+        const method = methodName ? String(methodName) : 'constructor';
+        let metaKey;
+
+        switch (true) {
+            case A_TypeGuards.isComponentConstructor(target) || A_TypeGuards.isComponentInstance(target):
+                metaKey = A_TYPES__ComponentMetaKey.INJECTIONS;
+                break;
+
+            case A_TypeGuards.isContainerInstance(target):
+                metaKey = A_TYPES__ContainerMetaKey.INJECTIONS;
+                break;
+        }
+
+        // get existing meta or create a new one
+        const existedMeta = A_Context.meta(target).get(metaKey) || new A_Meta();
+        // get existing injections for the method or create a new array
+        const paramsArray: A_TYPES__A_InjectDecorator_Meta = existedMeta.get(method) || [];
+
+        // set the parameter injection info
+        paramsArray[parameterIndex] = {
+            ...(paramsArray[parameterIndex] || {}),
+            load: path
+        }
+        // save back the updated injections array
+        existedMeta.set(method, paramsArray);
+
+        // save back the updated meta info
+        A_Context
+            .meta(target)
+            .set(
+                metaKey,
+                existedMeta
+            );
+    }
+}

package/src/global/A-Dependency/A-Dependency-Require.decorator.ts

@@ -0,0 +1,68 @@
+
+import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
+import { A_Meta } from "@adaas/a-concept/global/A-Meta/A-Meta.class";
+import { A_TYPES__ComponentMetaKey } from "@adaas/a-concept/global/A-Component/A-Component.constants";
+import { A_TYPES__ContainerMetaKey } from "@adaas/a-concept/global/A-Container/A-Container.constants";
+import { A_TypeGuards } from "@adaas/a-concept/helpers/A_TypeGuards.helper";
+import { A_TYPES__A_InjectDecorator_Meta, A_TYPES__InjectableTargets } from "../A-Inject/A-Inject.types";
+import { A_TYPES__A_Dependency_RequireDecoratorReturn } from "./A-Dependency.types";
+import { A_DependencyError } from "./A-Dependency.error";
+import { A_CommonHelper } from "@adaas/a-concept/helpers/A_Common.helper";
+
+
+/**
+ * Should indicate which dependency is required
+ */
+export function A_Dependency_Require(): A_TYPES__A_Dependency_RequireDecoratorReturn {
+
+    return function (
+        target: A_TYPES__InjectableTargets,
+        methodName: string | symbol | undefined,
+        parameterIndex: number
+    ) {
+        // for Error handling purposes
+        const componentName = A_CommonHelper.getComponentName(target)
+
+        if (!A_TypeGuards.isTargetAvailableForInjection(target)) {
+            throw new A_DependencyError(
+                A_DependencyError.InvalidDependencyTarget,
+                `A-Dependency cannot be used on the target of type ${typeof target} (${componentName})`
+            );
+        }
+
+        // determine the method name or 'constructor' for constructor injections
+        const method = methodName ? String(methodName) : 'constructor';
+        let metaKey;
+
+        switch (true) {
+            case A_TypeGuards.isComponentConstructor(target) || A_TypeGuards.isComponentInstance(target):
+                metaKey = A_TYPES__ComponentMetaKey.INJECTIONS;
+                break;
+
+            case A_TypeGuards.isContainerInstance(target):
+                metaKey = A_TYPES__ContainerMetaKey.INJECTIONS;
+                break;
+        }
+
+        // get existing meta or create a new one
+        const existedMeta = A_Context.meta(target).get(metaKey) || new A_Meta();
+        // get existing injections for the method or create a new array
+        const paramsArray: A_TYPES__A_InjectDecorator_Meta = existedMeta.get(method) || [];
+
+        // set the parameter injection info
+        paramsArray[parameterIndex] = {
+            ...(paramsArray[parameterIndex] || {}),
+            require: true
+        }
+        // save back the updated injections array
+        existedMeta.set(method, paramsArray);
+
+        // save back the updated meta info
+        A_Context
+            .meta(target)
+            .set(
+                metaKey,
+                existedMeta
+            );
+    }
+}

package/src/global/A-Dependency/A-Dependency.class.ts

@@ -0,0 +1,33 @@
+import { A_Dependency_Default } from "./A-Dependency-Default.decorator";
+import { A_Dependency_Load } from "./A-Dependency-Load.decorator";
+import { A_Dependency_Require } from "./A-Dependency-Require.decorator";
+
+
+export class A_Dependency {
+    /**
+     * Allows to indicate which Injected parameter is required
+     * 
+     * [!] If parameter marked as required is not provided, an error will be thrown
+     * 
+     * @returns 
+     */
+    static get Required(): typeof A_Dependency_Require {
+        return A_Dependency_Require;
+    }
+    /**
+     * Allows to indicate which dependency should be loaded from a specific path
+     * 
+     * @returns 
+     */
+    static get Loaded(): typeof A_Dependency_Load {
+        return A_Dependency_Load;
+    }
+    /**
+     * Allows to indicate which dependency default parameters should be used
+     * 
+     * @returns 
+     */
+    static get Default(): typeof A_Dependency_Default {
+        return A_Dependency_Default;
+    }
+}

package/src/global/A-Dependency/A-Dependency.error.ts

@@ -0,0 +1,13 @@
+import { A_Error } from "../A-Error/A_Error.class";
+
+export class A_DependencyError extends A_Error {
+
+    static readonly InvalidDependencyTarget = 'Invalid Dependency Target';
+
+    static readonly InvalidLoadTarget = 'Invalid Load Target';
+
+    static readonly InvalidLoadPath = 'Invalid Load Path';
+
+
+    static readonly InvalidDefaultTarget = 'Invalid Default Target';
+}

package/src/global/A-Dependency/A-Dependency.types.ts

@@ -0,0 +1,28 @@
+
+
+/**
+ * A-Dependency require decorator return type 
+ */
+export type A_TYPES__A_Dependency_RequireDecoratorReturn<T = any> = (
+    target: T,
+    propertyKey: string | symbol | undefined,
+    parameterIndex: number
+) => void
+
+/**
+ * A-Dependency load decorator return type 
+ */
+export type A_TYPES__A_Dependency_LoadDecoratorReturn<T = any> = (
+    target: T,
+    propertyKey: string | symbol | undefined,
+    parameterIndex: number
+) => void
+
+/**
+ * A-Dependency default decorator return type
+ */
+export type A_TYPES__A_Dependency_DefaultDecoratorReturn<T = any> = (
+    target: T,
+    propertyKey: string | symbol | undefined,
+    parameterIndex: number
+) => void

package/src/global/A-Feature/A-Feature-Define.decorator.ts

@@ -14,6 +14,7 @@ import { A_TYPES__ContainerMetaKey } from "@adaas/a-concept/global/A-Container/A
 import { A_TYPES__ComponentMetaKey } from "@adaas/a-concept/global/A-Component/A-Component.constants";
 import { A_TypeGuards } from "@adaas/a-concept/helpers/A_TypeGuards.helper";
 import { A_FeatureError } from "./A-Feature.error";
+import { A_CommonHelper } from "@adaas/a-concept/helpers/A_Common.helper";
 
 /**
  * A-Feature decorator
@@ -37,7 +38,7 @@ export function A_Feature_Define(
         descriptor: A_TYPES__FeatureDefineDecoratorDescriptor
     ) {
         // for error messages
-        const componentName = (target as any)?.constructor?.name || String(target) || 'Unknown';
+        const componentName = A_CommonHelper.getComponentName(target)
 
 
         if (!A_TypeGuards.isAllowedForFeatureDefinition(target))

package/src/global/A-Feature/A-Feature-Extend.decorator.ts

@@ -4,6 +4,7 @@ import { A_TYPES__FeatureExtendDecoratorConfig, A_TYPES__FeatureExtendDecoratorD
 import { A_TypeGuards } from "@adaas/a-concept/helpers/A_TypeGuards.helper";
 import { A_TYPES__ComponentMetaKey } from "../A-Component/A-Component.constants";
 import { A_FeatureError } from "./A-Feature.error";
+import { A_CommonHelper } from "@adaas/a-concept/helpers/A_Common.helper";
 
 
 
@@ -64,7 +65,7 @@ export function A_Feature_Extend(
         descriptor: A_TYPES__FeatureExtendDecoratorDescriptor
     ) {
         // for error messages
-        const componentName = (target as any)?.constructor?.name || String(target) || 'Unknown';
+        const componentName = A_CommonHelper.getComponentName(target)
 
         if (!A_TypeGuards.isAllowedForFeatureExtension(target))
             throw new A_FeatureError(

package/src/global/A-Feature/A-Feature.class.ts

@@ -135,6 +135,12 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
      * The Scope allocated for the Feature Execution
      */
     get scope(): A_Scope { return A_Context.scope(this); }
+    /**
+     * The number of stages in the feature
+     */
+    get size(): number {
+        return this._stages.length;
+    }
 
     /**
      * This method checks if the A-Feature is done
@@ -357,7 +363,10 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
      * @returns 
      */
     async completed(): Promise<void> {
+
         this._state = A_TYPES__FeatureState.COMPLETED;
+
+        this.scope.destroy();
     }
     /**
      * This method marks the feature as failed and throws an error
@@ -390,6 +399,8 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
         }
 
         this._state = A_TYPES__FeatureState.INTERRUPTED;
+
+        this.scope.destroy();
     }
 
 

package/src/global/A-Inject/A-Inject.decorator.ts

@@ -1,5 +1,6 @@
 import {
     A_TYPES__A_InjectDecorator_EntityInjectionInstructions,
+    A_TYPES__A_InjectDecorator_Meta,
     A_TYPES__A_InjectDecoratorReturn,
     A_TYPES__InjectableConstructors,
     A_TYPES__InjectableTargets
@@ -21,6 +22,7 @@ import { A_TYPES__Fragment_Constructor } from "@adaas/a-concept/global/A-Fragmen
 import { A_Scope } from "@adaas/a-concept/global/A-Scope/A-Scope.class";
 import { A_TYPES__Scope_Constructor } from "@adaas/a-concept/global/A-Scope/A-Scope.types";
 import { A_Feature } from "@adaas/a-concept/global/A-Feature/A-Feature.class";
+import { A_CommonHelper } from "@adaas/a-concept/helpers/A_Common.helper";
 
 
 /**
@@ -120,7 +122,7 @@ export function A_Inject(
         parameterIndex: number
     ) {
         // for Error handling purposes
-        const componentName = (target as any).name || (target.constructor && (target.constructor as any).name);
+        const componentName = A_CommonHelper.getComponentName(target)
 
         if (!A_TypeGuards.isTargetAvailableForInjection(target)) {
             throw new A_InjectError(
@@ -146,7 +148,7 @@ export function A_Inject(
         // get existing meta or create a new one
         const existedMeta = A_Context.meta(target).get(metaKey) || new A_Meta();
         // get existing injections for the method or create a new array
-        const paramsArray = existedMeta.get(method) || [];
+        const paramsArray: A_TYPES__A_InjectDecorator_Meta = existedMeta.get(method) || [];
 
         // set the parameter injection info
         paramsArray[parameterIndex] = {

package/src/global/A-Inject/A-Inject.types.ts

@@ -32,9 +32,11 @@ export type A_TYPES__A_InjectDecoratorReturn<T = any> = (
 
 export type A_TYPES__A_InjectDecorator_Meta = Array<{
     target: A_TYPES__InjectableConstructors
-} | {
-    target: A_TYPES__Entity_Constructor,
-    instructions: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions>
+    require?: boolean
+    load?: string
+    defaultArgs?: any,
+    create?: boolean
+    instructions?: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions>,
 }>;
 
 /**