@adaas/a-concept 0.1.23 → 0.1.25

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(
@@ -74,8 +75,9 @@ export function A_Feature_Extend(
 
         let targetRegexp: RegExp;
         let behavior: 'sync' | 'async' = 'sync';
-        let before: string[] = [];
-        let after: string[] = [];
+        let before: string = '';
+        let after: string = '';
+        let override: string = '';
         let include: Array<A_TYPES__FeatureExtendDecoratorScopeItem> = [];
         let exclude: Array<A_TYPES__FeatureExtendDecoratorScopeItem> = [];
         let throwOnError: boolean = true;
@@ -104,19 +106,22 @@ export function A_Feature_Extend(
                 behavior = param1.behavior || behavior;
                 throwOnError = param1.throwOnError !== undefined ? param1.throwOnError : throwOnError;
 
-                before = param1.before
-                    ?.map(e =>
-                        e instanceof RegExp
-                            ? e.source
-                            : new RegExp(`^.*${e.replace(/\./g, '\\.')}$`).source)
-                    || before;
-                after = param1.after
-                    ?.map(e =>
-                        e instanceof RegExp
-                            ? e.source
-                            : new RegExp(`^.*${e.replace(/\./g, '\\.')}$`).source)
-                    || after;
-
+                before = A_TypeGuards.isArray(param1.before)
+                    ? new RegExp(`^${param1.before.join('|').replace(/\./g, '\\.')}$`).source
+                    : param1.before instanceof RegExp
+                        ? param1.before.source
+                        : ''
+                after = A_TypeGuards.isArray(param1.after)
+                    ? new RegExp(`^${param1.after.join('|').replace(/\./g, '\\.')}$`).source
+                    : param1.after instanceof RegExp
+                        ? param1.after.source
+                        : ''
+
+                override = A_TypeGuards.isArray(param1.override)
+                    ? new RegExp(`^${param1.override.join('|').replace(/\./g, '\\.')}$`).source
+                    : param1.override instanceof RegExp
+                        ? param1.override.source
+                        : ''
                 break;
 
             default:
@@ -161,7 +166,8 @@ export function A_Feature_Extend(
             behavior,
             before,
             after,
-            throwOnError
+            throwOnError,
+            override
         }
 
         if (existedIndex !== -1) {

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
@@ -285,7 +291,7 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
         this._name = params.name;
 
         // 2) get scope from where feature is called
-        const componentScope = A_Context.scope(params.component);
+        const componentScope = params.scope ? params.scope : A_Context.scope(params.component);
 
         // 3) create caller wrapper for the simple injection of the caller component
         this._caller = new A_Caller<T>(params.component);
@@ -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-Feature/A-Feature.types.ts

@@ -38,6 +38,13 @@ export type A_TYPES__Feature_InitWithComponent<T extends A_TYPES__FeatureAvailab
      * [!] Could be Container, Entity, Component or Command
      */
     component: T,
+
+    /**
+     * In case when Entity is not attached to the scope can be used to transparently show dependencies
+     * 
+     * 
+     */
+    scope?: A_Scope
 }
 /**
  * Feature initialization type using template
@@ -259,11 +266,16 @@ export type A_TYPES__FeatureExtendDecoratorConfig = {
      * ```ts
      *  @A_Feature.Extend({
      *      name: 'load',
-     *      before: ['Component1.methodName', /Component2\..+/]
+     *      before: ['Component1.methodName', 'Component2.methodName2']
+     *  })
+     *  // OR
+     *  @A_Feature.Extend({
+     *      name: 'load',
+     *      before: /Component2\..+/
      *  })
      * ```
      */
-    before: Array<string | RegExp>
+    before: Array<string> | RegExp
 
     /**
      * Allows to define the order of the execution of the method.
@@ -275,19 +287,28 @@ export type A_TYPES__FeatureExtendDecoratorConfig = {
      * ```ts
      *  @A_Feature.Extend({
      *      name: 'load',
-     *      before: ['Component1.methodName', /Component2\..+/]
+     *      after: ['Component1.methodName', 'Component2.methodName2']
+     *  })
+     *  // OR
+     *  @A_Feature.Extend({
+     *      name: 'load',
+     *      after: /Component2\..+/
      *  })
      * ```
      * 
      */
-    after: Array<string | RegExp>
-
+    after: Array<string> | RegExp
     /**
      * Indicates whether to throw an error if the step fails.
      * 
      * [!] By default is true
      */
     throwOnError: boolean
+
+    /**
+     * Allows to override particular steps in the feature sequence by provided names [Component].[Method] or by regexp
+     */
+    override: Array<string> | RegExp
 }
 /**
  * Scope item that can be used in A_Extend decorator configuration
@@ -342,20 +363,24 @@ export type A_TYPES__FeatureExtendDecoratorMeta = {
      * [!] In case the method has circular dependencies it will Throw an error.
      * 
      */
-    before: string[]
+    before: string
     /**
      * Allows to define the order of the execution of the method.
      * 
      * [!] In case the method has circular dependencies it will Throw an error.
      * 
      */
-    after: string[]
+    after: string
     /**
      * Indicates whether to throw an error if the step fails.
      * 
      * [!] By default is true
      */
-    throwOnError: boolean
+    throwOnError: boolean,
+    /**
+     * Allows to override particular steps in the feature sequence by provided names [Component].[Method] or by regexp
+     */
+    override: string
 }
 
 

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>,
 }>;
 
 /**

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

@@ -10,6 +10,7 @@ import {
     A_TYPES__A_InjectDecorator_EntityInjectionInstructions,
     A_TYPES__A_InjectDecorator_EntityInjectionQuery,
     A_TYPES__InjectableConstructors,
+    A_TYPES__InjectableTargets,
 } from "@adaas/a-concept/global/A-Inject/A-Inject.types";
 import { A_Fragment } from "../A-Fragment/A-Fragment.class";
 import { A_Context } from "../A-Context/A-Context.class";
@@ -267,6 +268,31 @@ export class A_Scope<
     protected initFragments(_fragments?: _FragmentType) { _fragments?.forEach(this.register.bind(this)); }
 
 
+    // ==========================================================================
+    // --------------------Scope Public Methods-----------------------------------
+    // ==========================================================================
+    /**
+     * This method is used to destroy the scope and all its registered components, fragments and entities
+     * 
+     * [!] This method deregisters all components, fragments and entities from the A-Context
+     * [!] This method also clears all internal registries and collections
+     */
+    destroy() {
+        this._components.forEach(component => A_Context.deregister(component));
+        this._fragments.forEach(fragment => A_Context.deregister(fragment));
+        this._entities.forEach(entity => A_Context.deregister(entity));
+
+        this._components.clear();
+        this._errors.clear();
+        this._fragments.clear();
+        this._entities.clear();
+
+        if (this.issuer()) {
+            A_Context.deallocate(this);
+        }
+    }
+
+
     /**
      * Returns the issuer of the scope, useful for debugging and tracking purposes
      * 
@@ -499,7 +525,7 @@ export class A_Scope<
          */
         name: string
     ): A_TYPES__Fragment_Constructor<T>
-    resolveConstructor<T extends A_TYPES__ScopeResolvableComponents>(name: string): A_TYPES__Entity_Constructor<T> | A_TYPES__Component_Constructor<T> | A_TYPES__Fragment_Constructor<T> {
+    resolveConstructor<T extends A_TYPES__ScopeResolvableComponents>(name: string): A_TYPES__Entity_Constructor<T> | A_TYPES__Component_Constructor<T> | A_TYPES__Fragment_Constructor<T> | undefined {
         // 1) Check components
         const component = Array.from(this.allowedComponents).find(
             c => c.name === name
@@ -527,10 +553,7 @@ export class A_Scope<
             return this._parent.resolveConstructor(name) as any;
         }
 
-        throw new A_ScopeError(
-            A_ScopeError.ResolutionError,
-            `Component or Entity with name ${name} not found in the scope ${this.name}`
-        );
+        return undefined;
     }
 
 
@@ -550,25 +573,25 @@ export class A_Scope<
          * Provide a component constructor to resolve its instance from the scope
          */
         component: A_TYPES__Component_Constructor<T>
-    ): T
+    ): T | undefined
     resolve<T extends A_TYPES__Component_Constructor[]>(
         /**
          * Provide an array of component constructors to resolve their instances from the scope
          */
         components: [...T]
-    ): Array<InstanceType<T[number]>>
+    ): Array<InstanceType<T[number]>> | undefined
     resolve<T extends A_Fragment>(
         /**
          * Provide a fragment constructor to resolve its instance from the scope
          */
         fragment: A_TYPES__Fragment_Constructor<T>
-    ): T
+    ): T | undefined
     resolve<T extends A_TYPES__Fragment_Constructor[]>(
         /**
          * Provide an array of fragment constructors to resolve their instances from the scope
          */
         fragments: [...T]
-    ): Array<InstanceType<T[number]>>
+    ): Array<InstanceType<T[number]>> | undefined
     resolve<T extends A_Entity>(
         /**
          * Provide an entity constructor to resolve its instance or an array of instances from the scope
@@ -582,7 +605,7 @@ export class A_Scope<
          * Provide an entity constructor to resolve its instance from the scope
          */
         scope: new (...args: any[]) => T
-    ): T
+    ): T | undefined
     resolve<T extends A_Entity>(
         /**
          * Provide an entity constructor to resolve its instance or an array of instances from the scope
@@ -595,7 +618,7 @@ export class A_Scope<
     ): Array<T>
     resolve<T extends A_TYPES__ScopeResolvableComponents>(
         constructorName: string
-    ): T
+    ): T | undefined
     // base definition
     resolve<T extends A_TYPES__ScopeResolvableComponents>(
         /**
@@ -603,21 +626,21 @@ export class A_Scope<
          */
         param1: A_TYPES__InjectableConstructors,
 
-    ): T | Array<T>
+    ): T | Array<T> | undefined
     resolve<T extends A_TYPES__ScopeLinkedConstructors>(
         /**
          * Provide a component, fragment or entity constructor or an array of constructors to resolve its instance(s) from the scope
          */
         param1: InstanceType<T>,
 
-    ): T | Array<T>
+    ): T | Array<T> | undefined
     resolve<T extends A_TYPES__ScopeResolvableComponents>(
         /**
          * Provide a component, fragment or entity constructor or an array of constructors to resolve its instance(s) from the scope
          */
         param1: A_TYPES__InjectableConstructors | Array<A_TYPES__InjectableConstructors>,
         param2?: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions>
-    ): T | Array<T> {
+    ): T | Array<T> | undefined {
         switch (true) {
             case A_TypeGuards.isArray(param1): {
                 return param1.map(c => {
@@ -637,7 +660,9 @@ export class A_Scope<
             }
 
             default: {
-                throw new A_Error(`Invalid parameter provided to resolve method: ${param1} in scope ${this.name}`);
+                throw new A_ScopeError(
+                    A_ScopeError.ResolutionError,
+                    `Invalid parameter provided to resolve method: ${param1} in scope ${this.name}`);
             }
         }
     }
@@ -663,7 +688,7 @@ export class A_Scope<
          * Provide the name of the component, fragment or entity to resolve
          */
         name: string
-    ): _EntityType[number] | InstanceType<_ComponentType[number]> | _FragmentType[number] {
+    ): _EntityType[number] | InstanceType<_ComponentType[number]> | _FragmentType[number] | undefined {
         // 1) Check components
         const component = Array.from(this.allowedComponents).find(
             c => c.name === name
@@ -691,10 +716,7 @@ export class A_Scope<
             return this._parent.resolveByName(name) as any;
         }
 
-        throw new A_ScopeError(
-            A_ScopeError.ResolutionError,
-            `Component or Entity with name ${name} not found in the scope ${this.name}`
-        );
+        return undefined;
     }
 
     /**
@@ -707,22 +729,12 @@ export class A_Scope<
     private resolveOnce(
         component: any,
         instructions?: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions>
-    ): A_TYPES__ScopeResolvableComponents | A_Scope | A_TYPES__ScopeLinkedComponents | Array<A_TYPES__ScopeResolvableComponents> {
-
-        const componentName = A_TypeGuards.isFunction(component) ? component.name : component.constructor.name || String(component);
+    ): A_TYPES__ScopeResolvableComponents | A_Scope | A_TYPES__ScopeLinkedComponents | Array<A_TYPES__ScopeResolvableComponents> | undefined {
 
+        const componentName = A_CommonHelper.getComponentName(component);
 
         if (!component || !this.has(component))
-            throw new A_ScopeError(
-                A_ScopeError.ResolutionError,
-                `Injected Component ${componentName} not found in the scope`
-            );
-
-        if (A_TypeGuards.isScopeConstructor(component))
-            component
-
-        if (typeof component == 'function' && component.name === 'A_Scope')
-            component
+            return undefined;
 
         switch (true) {
             case A_TypeGuards.isConstructorAllowedForScopeAllocation(component): {
@@ -750,7 +762,7 @@ export class A_Scope<
 
     private resolveIssuer(
         ctor: A_TYPES__ScopeLinkedConstructors
-    ): A_TYPES__ScopeLinkedComponents {
+    ): A_TYPES__ScopeLinkedComponents | undefined {
 
         const issuer = this.issuer();
 
@@ -765,10 +777,7 @@ export class A_Scope<
             return this._parent.resolveIssuer(ctor);
         }
 
-        throw new A_ScopeError(
-            A_ScopeError.ResolutionError,
-            `Issuer ${ctor.name} not found in the scope ${this.name}`
-        );
+        return undefined;
     }
 
     /**
@@ -783,7 +792,7 @@ export class A_Scope<
     private resolveEntity<T extends A_Entity>(
         entity: A_TYPES__Entity_Constructor<T>,
         instructions?: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions<T>>
-    ): T | Array<T> {
+    ): T | Array<T> | undefined {
 
         const query = instructions?.query || {} as Partial<A_TYPES__A_InjectDecorator_EntityInjectionQuery<T>>;
         const count = instructions?.pagination?.count || 1;
@@ -806,10 +815,7 @@ export class A_Scope<
                         return this._parent.resolveEntity(entity, instructions);
 
                     default:
-                        throw new A_ScopeError(
-                            A_ScopeError.ResolutionError,
-                            `Entity ${entity.name} not found in the scope ${this.name}`
-                        );
+                        return undefined;
                 }
             }
             /**
@@ -884,7 +890,7 @@ export class A_Scope<
      * @param fragment 
      * @returns 
      */
-    private resolveFragment<T extends A_Fragment>(fragment: A_TYPES__Fragment_Constructor<T>): _FragmentType[number] {
+    private resolveFragment<T extends A_Fragment>(fragment: A_TYPES__Fragment_Constructor<T>): _FragmentType[number] | undefined {
         const fragmentInstancePresented = this._fragments.get(fragment);
 
         switch (true) {
@@ -895,10 +901,7 @@ export class A_Scope<
                 return this._parent.resolveFragment(fragment);
 
             default:
-                throw new A_ScopeError(
-                    A_ScopeError.ResolutionError,
-                    `Fragment ${fragment.name} not found in the scope ${this.name}`
-                );
+                return undefined;
         }
     }
     /**
@@ -916,7 +919,7 @@ export class A_Scope<
      * @param component 
      * @returns 
      */
-    private resolveComponent<T extends A_Component>(component: A_TYPES__Component_Constructor<T>): InstanceType<_ComponentType[number]> {
+    private resolveComponent<T extends A_Component>(component: A_TYPES__Component_Constructor<T>): InstanceType<_ComponentType[number]> | undefined {
 
         //  The idea here that in case when Scope has no exact component we have to resolve it from the _parent
         //  BUT: if it's not presented in _parent  we have to check for inheritance
@@ -935,15 +938,40 @@ export class A_Scope<
 
                 const resolvedArgs = (argsMeta?.get('constructor') || [])
                     .map(arg => {
-                        if ('instructions' in arg) {
+                        // for Error handling purposes
+                        const componentName = A_CommonHelper.getComponentName(arg.target)
+
+                        if ('instructions' in arg && !!arg.instructions) {
                             const { target, instructions } = arg
-                            return this.resolve(
-                                target,
-                                instructions
-                            );
+                            const dependency = this.resolve(target as any, instructions);
+                            if (!dependency)
+                                throw new A_ScopeError(
+                                    A_ScopeError.ResolutionError,
+                                    `Unable to resolve dependency ${componentName} for component ${component.name} in scope ${this.name}`
+                                );
+
+                            return dependency;
+                        } else {
+                            const { target, require, create, defaultArgs } = arg;
+
+                            let dependency = this.resolve(target as any);
+
+                            if (create && !dependency && A_TypeGuards.isAllowedForDependencyDefaultCreation(target)) {
+                                const newDependency = new target(...defaultArgs);
+
+                                this.register(newDependency);
+                                return newDependency;
+                            }
+
+                            if (require && !dependency) {
+                                throw new A_ScopeError(
+                                    A_ScopeError.ResolutionError,
+                                    `Unable to resolve required dependency ${componentName} for component ${component.name} in scope ${this.name}`
+                                );
+                            }
+
+                            return dependency;
                         }
-                        // TODO: Fix types mismatch here
-                        return this.resolve<T>(arg.target as any);
                     });
 
                 const newComponent = new component(...resolvedArgs)
@@ -1128,7 +1156,7 @@ export class A_Scope<
                         `Fragment ${param1.constructor.name} is already registered in the scope ${this.name}`
                     );
                 else {
-                    const componentName = A_TypeGuards.isFunction(param1) ? param1.name : param1?.constructor?.name || String(param1);
+                    const componentName = A_CommonHelper.getComponentName(param1);
 
                     throw new A_ScopeError(
                         A_ScopeError.RegistrationError,

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

@@ -12,6 +12,7 @@ import { A_TypeGuards } from "@adaas/a-concept/helpers/A_TypeGuards.helper";
 import { A_TYPES__ScopeResolvableComponents } from "../A-Scope/A-Scope.types";
 import { A_TYPES__Container_Constructor } from "../A-Container/A-Container.types";
 import { A_TYPES__Component_Constructor } from "../A-Component/A-Component.types";
+import { A_CommonHelper } from "@adaas/a-concept/helpers/A_Common.helper";
 
 
 
@@ -141,11 +142,30 @@ export class A_Stage {
                         case A_TypeGuards.isFeatureConstructor(arg.target):
                             return this._feature;
 
-                        case A_TypeGuards.isEntityConstructor(arg.target) && 'instructions' in arg:
+                        case A_TypeGuards.isEntityConstructor(arg.target) && 'instructions' in arg && !!arg.instructions:
                             return scope.resolve(arg.target, arg.instructions)
 
-                        default:
+                        default: {
+                            const { target, require, create, defaultArgs } = arg;
+
+                            let dependency = scope.resolve(target as any);
+
+                            if (create && !dependency && A_TypeGuards.isAllowedForDependencyDefaultCreation(target)) {
+                                const newDependency = new target(...defaultArgs);
+
+                                scope.register(newDependency);
+                                return newDependency;
+                            }
+
+                            if (require && !dependency) {
+                                throw new A_StageError(
+                                    A_StageError.ArgumentsResolutionError,
+                                    `Unable to resolve required argument ${A_CommonHelper.getComponentName(arg.target)} for stage ${this.name} in scope ${scope.name}`
+                                );
+                            }
+
                             return scope.resolve(arg.target)
+                        }
                     }
                 })
             )

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

@@ -3,6 +3,8 @@ import { A_Error } from "../A-Error/A_Error.class";
 
 export class A_StageError extends A_Error {
 
+    static readonly ArgumentsResolutionError = 'A-Stage Arguments Resolution Error';
+
 
     static get CompileError(): string {
         return 'Unable to compile A-Stage';

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

@@ -76,7 +76,7 @@ export type A_TYPES__A_StageStep = {
      * [!] In case the method has circular dependencies it will Throw an error.
      * 
      */
-    before: string[]
+    before: string
 
     /**
      * Allows to define the order of the execution of the method.
@@ -84,7 +84,7 @@ export type A_TYPES__A_StageStep = {
      * [!] In case the method has circular dependencies it will Throw an error.
      * 
      */
-    after: string[],
+    after: string,
 
     /**
      * Indicates whether to throw an error if the step fails.
@@ -92,6 +92,11 @@ export type A_TYPES__A_StageStep = {
      * [!] By default is true
      */
     throwOnError: boolean
+
+    /**
+     * 
+     */
+    override: string
 }