@adaas/a-concept 0.0.39 → 0.0.41

package/src/global/A-Concept/A_Concept.class.ts

@@ -3,6 +3,7 @@ import { A_Container } from "../A-Container/A-Container.class";
 import { A_Abstraction } from "../A-Abstraction/A-Abstraction.class";
 import { A_ConceptMeta } from "./A_Concept.meta";
 import { A_Abstraction_Extend } from "@adaas/a-concept/decorators/A-Abstraction/A-Abstraction-Extend.decorator";
+import { A_Scope } from "../A-Scope/A-Scope.class";
 
 
 // export type RunParams<T> = T extends A_Container<any, infer Params> ? Params : never;
@@ -98,18 +99,16 @@ export class A_Concept<
         protected props: A_TYPES__IConceptConstructor<_Imports>
     ) {
         this.sharedBase = new A_Container({
-            name: props.name,
+            name: `${props.name}::base`,
             fragments: props.fragments || [],
             entities: props.entities || [],
-            // containers: props.containers
             components: [
                 // A_Logger,
-            ]
+            ],
         });
 
         this.containers = (props.containers || []).map(container => {
             container.Scope.parent(this.Scope);
-
             return container;
         });
 
@@ -136,9 +135,11 @@ export class A_Concept<
      * Load the concept.
      */
     async load(
-        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
+        scope?: A_Scope,
     ) {
-        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Load, params);
+        scope = scope ? scope.inherit(this.Scope) : this.Scope;
+
+        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Load, scope);
 
         await abstraction.process();
     }
@@ -149,11 +150,11 @@ export class A_Concept<
      * Run the concept.
      */
     async run(
-        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
+        scope?: A_Scope,
     ) {
-        await this.load(params);
+        scope = scope ? scope.inherit(this.Scope) : this.Scope;
 
-        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Run, params);
+        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Run, scope);
 
         await abstraction.process();
     }
@@ -165,11 +166,11 @@ export class A_Concept<
      * @param params 
      */
     async start(
-        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
+        scope?: A_Scope,
     ) {
-        await this.load(params);
+        scope = scope ? scope.inherit(this.Scope) : this.Scope;
 
-        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Start, params);
+        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Start, scope);
 
         await abstraction.process();
     }
@@ -181,9 +182,11 @@ export class A_Concept<
      * @param params 
      */
     async stop(
-        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
+        scope?: A_Scope,
     ) {
-        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Stop, params);
+        scope = scope ? scope.inherit(this.Scope) : this.Scope;
+
+        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Stop, scope);
 
         await abstraction.process();
     }
@@ -193,9 +196,11 @@ export class A_Concept<
      * Build the concept.
      */
     async build(
-        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
+        scope?: A_Scope,
     ) {
-        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Build, params);
+        scope = scope ? scope.inherit(this.Scope) : this.Scope;
+
+        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Build, scope);
 
         await abstraction.process();
     }
@@ -205,9 +210,11 @@ export class A_Concept<
      * Deploy the concept.
      */
     async deploy(
-        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
+        scope?: A_Scope,
     ) {
-        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Deploy, params);
+        scope = scope ? scope.inherit(this.Scope) : this.Scope;
+
+        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Deploy, scope);
 
         await abstraction.process();
 
@@ -218,9 +225,11 @@ export class A_Concept<
      * Publish the concept.
      */
     async publish(
-        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
+        scope?: A_Scope,
     ) {
-        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Publish, params);
+        scope = scope ? scope.inherit(this.Scope) : this.Scope;
+
+        const abstraction = this.meta.abstraction(A_TYPES__ConceptStage.Publish, scope);
 
         await abstraction.process();
     }
@@ -238,7 +247,6 @@ export class A_Concept<
         K extends Record<_Imports[number]['name'], string>
     >(
         container: K[keyof K],
-        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
     ) {
         // const definition = this.meta.abstractionDefinition(A_TYPES__ConceptStage.Run, {
         //     components: params?.components,

package/src/global/A-Concept/A_Concept.meta.ts

@@ -9,6 +9,7 @@ import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
 import { A_TYPES__A_FeatureDecoratorConfig } from "@adaas/a-concept/decorators/A-Feature/A-Feature.decorator.types";
 import { A_TYPES__A_AbstractionConstructor } from "../A-Abstraction/A-Abstraction.types";
 import { A_Abstraction } from "../A-Abstraction/A-Abstraction.class";
+import { A_Scope } from "../A-Scope/A-Scope.class";
 // import { A_TYPES__ComponentMeta } from "./A-Component.types";
 
 
@@ -24,21 +25,17 @@ export class A_ConceptMeta extends A_Meta<any> {
 
     abstractionDefinition(
         method: A_TYPES__ConceptStage,
-        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
-    ): A_TYPES__Required<Partial<A_TYPES__A_AbstractionConstructor>, ['features']> {
+        scope: A_Scope
+    ): A_TYPES__A_AbstractionConstructor {
 
         const featureDefinitions = this.containers.map(container =>
-            A_Context.abstractionDefinition(container.Scope, container, method, params)
+            A_Context.abstractionDefinition(container, method, scope)
         );
 
-
         const definition = {
-            ...params,
             name: `${this.base.name}.${method}`,
             features: featureDefinitions,
-            parent: this.base.Scope,
-            components: params?.components || [],
-            fragments: params?.fragments || [],
+            scope
         };
 
         return definition;
@@ -48,12 +45,11 @@ export class A_ConceptMeta extends A_Meta<any> {
 
     abstraction(
         method: A_TYPES__ConceptStage,
-        params?: Partial<A_TYPES__ConceptAbstractionCallParams>
+        scope: A_Scope
     ): A_Abstraction {
 
-
         const featureDefinitions = this.containers.map(container => {
-            const definition = A_Context.abstractionDefinition(container.Scope, container, method, params);
+            const definition = A_Context.abstractionDefinition(container, method, container.Scope);
 
             return {
                 ...definition,
@@ -63,12 +59,9 @@ export class A_ConceptMeta extends A_Meta<any> {
 
 
         const definition = {
-            ...params,
             name: `${this.base.name}.${method}`,
             features: featureDefinitions,
-            parent: this.base.Scope,
-            components: params?.components || [],
-            fragments: params?.fragments || [],
+            scope
         };
 
         return new A_Abstraction(definition);

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

@@ -44,20 +44,20 @@ export class A_Container {
     ) {
         this.config = config;
 
-        const components = config.components || [];
-        const fragments = config.fragments || [];
-
-        A_Context.allocate(this, config);
-
-
+        A_Context.allocate(this, {
+            name: this.name,
+            ...config
+        });
     }
 
 
     async call(
         feature: string,
-        params: Partial<A_TYPES__FeatureCallParams> = {}
+        scope?: A_Scope,
     ) {
-        const newFeature = A_Context.feature(this.Scope, this, feature, params);
+        scope = scope ? scope.inherit(this.Scope) : this.Scope;
+
+        const newFeature = A_Context.feature(this, feature, scope);
 
         return await newFeature.process();
     }
@@ -70,10 +70,12 @@ export class A_Container {
      */
     feature(
         feature: string,
-        params: Partial<A_TYPES__FeatureCallParams> = {}
-    ): A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps', 'fragments', 'name', 'components']> {
+        scope?: A_Scope,
+    ): A_TYPES__FeatureConstructor {
+
+        scope = scope ? scope.inherit(this.Scope) : this.Scope;
 
-        return A_Context.featureDefinition(this.Scope, this, feature, params);
+        return A_Context.featureDefinition(this, feature, scope);
     }
 
 

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

@@ -118,22 +118,34 @@ export class A_Context {
         component: any,
         importing: Partial<A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig>
     ): A_Scope
+    static allocate(
+        component: any,
+        importing: Partial<A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig> | A_Scope
+    ): A_Scope
     static allocate(
         feature: A_Feature,
         importing: Partial<A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig>
     ): A_Scope
+    static allocate(
+        feature: A_Feature,
+        importing: Partial<A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig> | A_Scope
+    ): A_Scope
     static allocate(
         container: A_Container,
         importing: Partial<A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig>
     ): A_Scope
+    static allocate(
+        container: A_Container,
+        importing: A_Scope
+    ): A_Scope
     static allocate(
         param1: A_Container | A_Feature | A_Component | any,
-        param2: Partial<A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig>
+        param2: Partial<A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig> | A_Scope
     ): A_Scope {
 
         const instance = this.getInstance();
 
-        const newScope = new A_Scope(param2, param2);
+        const newScope = param2 instanceof A_Scope ? param2 : new A_Scope(param2, param2);
 
         switch (true) {
             case param1 instanceof A_Container:
@@ -345,33 +357,14 @@ export class A_Context {
      * @returns 
      */
     static featureDefinition(
-        scope: A_Scope,
-        entity: A_Entity,
-        feature: A_TYPES__EntityBaseMethod | string | RegExp,
-        params?: Partial<A_TYPES__ScopeConstructor>
-    ): A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps', 'fragments', 'name', 'components']>
-    static featureDefinition(
-        scope: A_Scope,
-        container: A_Container,
-        feature: string,
-        params?: Partial<A_TYPES__ScopeConstructor>
-    ): A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps', 'fragments', 'name', 'components']>
-    static featureDefinition(
-        scope: A_Scope,
-        component: A_Component,
-        feature: string,
-        params?: Partial<A_TYPES__ScopeConstructor>
-    ): A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps', 'fragments', 'name', 'components']>
-    static featureDefinition(
-        scope: A_Scope,
-        param1: A_Component | A_Container | A_Entity,
-        param2: string,
-        param3?: Partial<A_TYPES__ScopeConstructor>
-    ): A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps', 'fragments', 'name', 'components']> {
+        component: A_Component | A_Container | A_Entity,
+        feature: string | RegExp,
+        scope: A_Scope
+    ): A_TYPES__FeatureConstructor {
         const instance = this.getInstance();
 
-        const component = param1;
-        const config = param3 || {};
+        const name = `${component.constructor.name}.${feature}`;
+
 
         /**
          * Important NOTE::: Component Scope and Parent Scope are different things.
@@ -433,10 +426,10 @@ export class A_Context {
             throw new Error(`[!] A-Concept Context: Features not found. for Component ${component.constructor.name}`);
 
 
-        const featureDefinition = allFeatures.get(param2);
+        const featureDefinition = allFeatures.get(feature);
 
         if (!featureDefinition)
-            throw new Error(`[!] A-Concept Context: Feature ${param2} not found. for Component ${component.constructor.name}`);
+            throw new Error(`[!] A-Concept Context: Feature ${feature} not found. for Component ${component.constructor.name}`);
 
 
         const steps: A_TYPES__A_StageStep[] = [
@@ -449,7 +442,6 @@ export class A_Context {
         //     scope: scope.name
         // }).toString();
 
-        const feature = `${component.constructor.name}.${param2}`;
 
         // Now we need to resolve the method from all registered components 
 
@@ -460,7 +452,7 @@ export class A_Context {
                 if (scope.has(constructor))
                     // Get all extensions for the feature
                     meta
-                        .extensions(feature)
+                        .extensions(name)
                         .forEach((declaration) => {
                             steps.push({
                                 component: constructor,
@@ -470,14 +462,8 @@ export class A_Context {
             });
 
 
-        return {
-            name: feature,
-            fragments: config.fragments || [],
-            components: config.components || [],
-            entities: config.entities || [],
-            steps,
-            parent: scope
-        };
+
+        return { name, steps, scope };
     }
 
     /**
@@ -487,33 +473,13 @@ export class A_Context {
      * @returns 
      */
     static abstractionDefinition(
-        scope: A_Scope,
-        entity: A_Entity,
-        feature: A_TYPES__ConceptStage,
-        params?: Partial<A_TYPES__ScopeConstructor>
-    ): A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps', 'fragments', 'name', 'components']>
-    static abstractionDefinition(
-        scope: A_Scope,
-        container: A_Container,
-        feature: A_TYPES__ConceptStage,
-        params?: Partial<A_TYPES__ScopeConstructor>
-    ): A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps', 'fragments', 'name', 'components']>
-    static abstractionDefinition(
-        scope: A_Scope,
-        component: A_Component,
-        feature: A_TYPES__ConceptStage,
-        params?: Partial<A_TYPES__ScopeConstructor>
-    ): A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps', 'fragments', 'name', 'components']>
-    static abstractionDefinition(
-        scope: A_Scope,
-        param1: A_Component | A_Container | A_Entity,
-        param2: A_TYPES__ConceptStage,
-        param3?: Partial<A_TYPES__ScopeConstructor>
-    ): A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps', 'fragments', 'name', 'components']> {
+        component: A_Component | A_Container | A_Entity,
+        abstraction: A_TYPES__ConceptStage,
+        scope: A_Scope
+    ): A_TYPES__FeatureConstructor {
         const instance = this.getInstance();
 
-        const component = param1;
-        const config = param3 || {};
+        const name = `${component.constructor.name}.${abstraction}`;
 
         let metaKey;
 
@@ -534,14 +500,13 @@ export class A_Context {
 
         const featureDefinition = this.meta(component)
             .get(metaKey)
-            .get(param2) || []
+            .get(abstraction) || []
 
 
         const steps: A_TYPES__A_StageStep[] = [
             ...featureDefinition
         ];
 
-        const feature = `${component.constructor.name}.${param2}`;
 
         // We need to get all components that has extensions for the feature in component
         instance.componentsMeta
@@ -550,7 +515,7 @@ export class A_Context {
                 if (scope.has(constructor))
                     // Get all extensions for the feature
                     meta
-                        .abstractions(feature)
+                        .abstractions(name)
                         .forEach((declaration) => {
                             steps.push({
                                 component: constructor,
@@ -560,14 +525,7 @@ export class A_Context {
             });
 
 
-        return {
-            name: feature,
-            fragments: config.fragments || [],
-            components: config.components || [],
-            entities: config.entities || [],
-            steps,
-            parent: scope
-        };
+        return { name, steps, scope };
     }
 
     /**
@@ -577,31 +535,11 @@ export class A_Context {
      * @returns 
      */
     static feature<T extends Array<string>>(
-        scope: A_Scope,
-        entity: A_Entity<any, any>,
-        feature: A_TYPES__EntityBaseMethod | string | T[number] | RegExp,
-        params?: Partial<A_TYPES__ScopeConstructor>
-    ): A_Feature
-    static feature<T extends Array<string>>(
-        scope: A_Scope,
-        container: A_Container,
-        feature: T[number],
-        params?: Partial<A_TYPES__ScopeConstructor>
-    ): A_Feature
-    static feature(
-        scope: A_Scope,
-        component: A_Component,
-        feature: string,
-        params?: Partial<A_TYPES__ScopeConstructor>
-    ): A_Feature
-    static feature<T extends Array<string>>(
-        scope: A_Scope,
-        param1: A_Component | A_Container | A_Entity<any, any>,
-        param2: string | T[number],
-        param3?: Partial<A_TYPES__ScopeConstructor>
+        component: A_Component | A_Container | A_Entity<any, any>,
+        feature: string | T[number]| RegExp,
+        scope: A_Scope
     ): A_Feature {
-
-        const featureConstructor = this.featureDefinition(scope, param1, param2, param3);
+        const featureConstructor = this.featureDefinition(component, feature, scope);
 
         const newFeature = new A_Feature(featureConstructor);
 

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

@@ -10,6 +10,7 @@ import {
 import { A_CONSTANTS__DEFAULT_ERRORS } from "@adaas/a-utils/dist/src/constants/errors.constants";
 import { A_Context } from "../A-Context/A-Context.class";
 import { A_TYPES__FeatureCallParams } from "../A-Feature/A-Feature.types";
+import { A_Scope } from "../A-Scope/A-Scope.class";
 
 
 
@@ -135,14 +136,14 @@ export class A_Entity<
      * @param lifecycleMethod 
      * @param args 
      */
-     async call(
+    async call(
         feature: string,
-        params: Partial<A_TYPES__FeatureCallParams> = {}
+        scope?: A_Scope,
     ) {
-        params.entities = params.entities || [this];
 
+        scope = scope ? scope.inherit(A_Context.scope(this)) : A_Context.scope(this);
 
-        const newFeature = A_Context.feature(A_Context.scope(this), this, feature, params);
+        const newFeature = A_Context.feature(this, feature, scope);
 
         return await newFeature.process();
     }

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

@@ -6,6 +6,8 @@ import { A_Error, A_TYPES__Required } from "@adaas/a-utils";
 import { A_TYPES__A_Feature_Extend } from "@adaas/a-concept/decorators/A-Feature/A-Feature.decorator.types";
 import { A_Stage } from "../A-Stage/A-Stage.class";
 import { StepsManager } from "@adaas/a-concept/helpers/StepsManager.class";
+import { A_Scope } from "../A-Scope/A-Scope.class";
+import { A_StageError } from "../A-Stage/A-Stage.error";
 
 /**
  * A_Feature is representing a feature that can be executed across multiple components
@@ -46,11 +48,14 @@ export class A_Feature {
     error?: A_Error
 
     readonly name: string;
+    readonly Scope!: A_Scope;
+
 
     constructor(
-        params: A_TYPES__Required<Partial<A_TYPES__FeatureConstructor>, ['steps']>
+        params: A_TYPES__FeatureConstructor
     ) {
         this.name = params.name || this.constructor.name;
+        this.Scope = params.scope
 
         this.SM = new StepsManager(params.steps);
 
@@ -58,7 +63,17 @@ export class A_Feature {
 
         this._current = this.stages[0];
 
-        A_Context.allocate(this, params);
+
+        this.Scope.printInheritanceChain();
+    }
+
+
+    /**
+     * Returns the current A-Feature Stage
+     * 
+     */
+    get stage(): A_Stage | undefined {
+        return this._current;
     }
 
 
@@ -93,14 +108,6 @@ export class A_Feature {
     }
 
 
-    /**
-     * Returns the current A-Feature Stage
-     * 
-     */
-    get stage(): A_Stage | undefined {
-        return this._current;
-    }
-
 
 
     /**
@@ -144,7 +151,7 @@ export class A_Feature {
      */
     async completed<T extends any>(): Promise<T> {
 
-        this.result = A_Context.scope(this).toJSON();
+        this.result = this.Scope.toJSON();
 
         this.state = A_TYPES__FeatureState.COMPLETED;
 
@@ -173,7 +180,12 @@ export class A_Feature {
      * This method processes the feature by executing all the stages
      * 
      */
-    async process() {
+    async process(
+        scope?: A_Scope
+    ) {
+
+        console.log('Processing feature:', this.name);
+
         if (this.isDone()) {
             return this.result;
         }
@@ -182,43 +194,35 @@ export class A_Feature {
             this.state = A_TYPES__FeatureState.PROCESSING;
 
             for (const stage of this.stages) {
+                console.log('Processing stage:', stage.name);
+
                 await stage.process();
-            }
 
-            await this.completed();
+                console.log('Stage processed:', stage.name, 'Status:', stage.status);
+            }   
+
+
+            return await this.completed();
+
 
         } catch (error) {
-            await this.failed(error);
+
+            return await this.failed(error);
         }
-      
+
     }
 
 
     protected async errorHandler(error: Error | A_Error | unknown) {
+        console.log('Feature failed with error:', this.name);
+
         switch (true) {
+            case error instanceof A_StageError:
+                return; // Do nothing, already handled in the stage
+
             case error instanceof A_Error:
                 throw error;
 
-
-            case error instanceof Error
-                && error.message === 'FEATURE_PROCESSING_INTERRUPTED'
-                && this.state === A_TYPES__FeatureState.FAILED:
-                throw new A_Error({
-                    message: 'FEATURE_PROCESSING_INTERRUPTED',
-                    code: 'FEATURE_PROCESSING_INTERRUPTED',
-                    data: {
-                        feature: this
-                    }
-                });
-
-
-            case error instanceof Error
-                && error.message === 'FEATURE_PROCESSING_INTERRUPTED'
-                && this.state === A_TYPES__FeatureState.COMPLETED:
-
-                // Do nothing
-                break;
-
             default:
                 throw error;
         }

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

@@ -2,6 +2,7 @@ import { A_TYPES__ScopeConfig, A_TYPES__ScopeConstructor } from "../A-Scope/A-Sc
 import { A_TYPES__A_StageStep } from "../A-Stage/A-Stage.types"
 import { A_Fragment } from "../A-Fragment/A-Fragment.class"
 import { A_Entity } from "@adaas/a-concept/global/A-Entity/A-Entity.class"
+import { A_Scope } from "../A-Scope/A-Scope.class"
 
 
 export type A_TYPES__FeatureIteratorReturn<T extends any = any> = () => Promise<T>
@@ -16,8 +17,19 @@ export type A_TYPES__FeatureCallParams = {
 
 
 export type A_TYPES__FeatureConstructor = {
-    steps: A_TYPES__A_StageStep[]
-} & A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig
+    /**
+     * Name of the A-Feature
+     */
+    name:string,
+    /**
+     * Steps that compose the A-Feature
+     */
+    steps: A_TYPES__A_StageStep[],
+    /**
+     * Scope in which the A-Feature will be executed
+     */
+    scope: A_Scope
+}
 
 export enum A_TYPES__FeatureState {
     INITIALIZED = "INITIALIZED",