@adaas/a-concept 0.1.23 → 0.1.25

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@adaas/a-concept",
-  "version": "0.1.23",
+  "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(
@@ -91,18 +92,22 @@ export function A_Abstraction_Extend(
             behavior: config.behavior || 'sync',
             throwOnError: config.throwOnError !== undefined ? config.throwOnError : true,
 
-            before: (config.before
-                ?.map(b =>
-                    b instanceof RegExp
-                        ? b.source
-                        : new RegExp(`^.*${b.replace(/\./g, '\\.')}$`).source)
-                || []),
-            after: (config.after
-                ?.map(a =>
-                    a instanceof RegExp
-                        ? a.source
-                        : new RegExp(`^.*${a.replace(/\./g, '\\.')}$`).source)
-                || []),
+            before: A_TypeGuards.isArray(config.before)
+                ? new RegExp(`^${config.before.join('|').replace(/\./g, '\\.')}$`).source
+                : config.before instanceof RegExp
+                    ? config.before.source
+                    : '',
+            after: A_TypeGuards.isArray(config.after)
+                ? new RegExp(`^${config.after.join('|').replace(/\./g, '\\.')}$`).source
+                : config.after instanceof RegExp
+                    ? config.after.source
+                    : '',
+
+            override: A_TypeGuards.isArray(config.override)
+                ? new RegExp(`^${config.override.join('|').replace(/\./g, '\\.')}$`).source
+                : config.after instanceof RegExp
+                    ? config.after.source
+                    : '',
         }
 
         if (existedIndex !== -1) {

package/src/global/A-Component/A-Component.meta.ts

@@ -47,9 +47,10 @@ export class A_ComponentMeta extends A_Meta<A_TYPES__ComponentMeta> {
                         name: extension.name,
                         handler: extension.handler,
                         behavior: extension.behavior,
-                        before: extension.before || [],
-                        after: extension.after || [],
+                        before: extension.before || '',
+                        after: extension.after || '',
                         throwOnError: extension.throwOnError || true,
+                        override:''
                     });
 
                 });

package/src/global/A-Container/A-Container.meta.ts

@@ -64,13 +64,8 @@ export class A_ContainerMeta extends A_Meta<A_TYPES__ContainerMeta> {
                     const args = injections?.get(extension.handler) || [];
 
                     steps.push({
-                        name: extension.name,
-                        handler: extension.handler,
+                        ...extension,
                         args,
-                        before: extension.before,
-                        behavior: extension.behavior,
-                        after: extension.after,
-                        throwOnError: extension.throwOnError,
                     });
 
                 });
@@ -104,9 +99,11 @@ export class A_ContainerMeta extends A_Meta<A_TYPES__ContainerMeta> {
                         name: extension.name,
                         handler: extension.handler,
                         behavior: extension.behavior,
-                        before: extension.before || [],
-                        after: extension.after || [],
+                        before: extension.before || '',
+                        after: extension.after || '',
                         throwOnError: extension.throwOnError || true,
+                        override: ''
+
                     });
 
                 });

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-Entity/A-Entity.class.ts

@@ -254,7 +254,8 @@ export class A_Entity<
     ) {
         const newFeature = new A_Feature({
             name: feature,
-            component: this
+            component: this,
+            scope
         });
 
         return await newFeature.process(scope);

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))
@@ -87,10 +88,12 @@ export function A_Feature_Define(
             template: config.template && config.template.length ? config.template.map(
                 item => ({
                     ...item,
-                    before: item.before || [],
-                    after: item.after || [],
+                    before: item.before || '',
+                    after: item.after || '',
                     behavior: item.behavior || 'sync',
-                    throwOnError: true
+                    throwOnError: true,
+                    override: item.override || ''
+
                 })
             ) : [],
         });