@adaas/a-concept 0.0.38 → 0.0.40

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,7 @@ 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";
 
 /**
  * A_Feature is representing a feature that can be executed across multiple components
@@ -46,11 +47,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 +62,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 +107,6 @@ export class A_Feature {
     }
 
 
-    /**
-     * Returns the current A-Feature Stage
-     * 
-     */
-    get stage(): A_Stage | undefined {
-        return this._current;
-    }
-
 
 
     /**
@@ -144,7 +150,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 +179,10 @@ export class A_Feature {
      * This method processes the feature by executing all the stages
      * 
      */
-    async process() {
+    async process(
+        scope?: A_Scope
+    ) {
+
         if (this.isDone()) {
             return this.result;
         }
@@ -190,7 +199,7 @@ export class A_Feature {
         } catch (error) {
             await this.failed(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",

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

@@ -51,8 +51,6 @@ export class A_Scope {
             components: [],
             fragments: [],
             entities: [],
-            // import: [],
-            // export: [],
         };
 
 
@@ -102,14 +100,63 @@ export class A_Scope {
         setValue?: A_Scope
     ): A_Scope | undefined {
         if (setValue) {
-            this._parent = setValue;
-            return;
+            return this.inherit(setValue);
         }
 
         return this._parent;
     }
 
 
+    inherit(parent: A_Scope): A_Scope {
+        // Prevent circular inheritance
+        const circularCheck = this.checkCircularInheritance(parent);
+
+        if (circularCheck) {
+            throw new Error(`Circular inheritance detected: ${[...circularCheck, parent.name].join(' -> ')}`);
+        }
+
+        this._parent = parent;
+        return this;
+    }
+
+
+
+    /**
+     * Helper method to check circular inheritance
+     * Should return a full sequence of inheritance for logging purposes
+     * 
+     * @param scope 
+     * @returns 
+     */
+    checkCircularInheritance(scope: A_Scope): Array<string> | false {
+        const inheritanceChain: Array<string> = [];
+        let current: A_Scope | undefined = this._parent;
+
+        while (current) {
+            inheritanceChain.push(current.name);
+            if (current === scope) {
+                return inheritanceChain;
+            }
+            current = current._parent;
+        }
+
+        return false;
+    }
+
+
+    printInheritanceChain(): void {
+        const chain: Array<string> = [];
+        let current: A_Scope | undefined = this;
+
+        while (current) {
+            chain.push(current.name);
+            current = current._parent;
+        }
+
+        console.log(chain.join(' -> '));
+    }
+
+
     /**
      * This method is used to check if the component is available in the scope
      * 
@@ -169,6 +216,10 @@ export class A_Scope {
     /**
      * Merges two scopes into a new one
      * 
+     * [!] Notes: 
+     *  - this method does NOT modify the existing scopes
+     *  - parent of the new scope will be the parent of the current scope or the parent of anotherScope (if exists)
+     * 
      * @param anotherScope 
      * @returns 
      */
@@ -462,7 +513,12 @@ export class A_Scope {
             }
 
             default:
-                throw new Error('Invalid arguments provided');
+                if (param1 instanceof A_Entity)
+                    throw new Error(`Entity with ASEID ${param1.aseid.toString()} is already registered in the scope ${this.name}`);
+                else if (param1 instanceof A_Fragment)
+                    throw new Error(`Fragment ${param1.constructor.name} is already registered in the scope ${this.name}`);
+                else
+                    throw new Error(`Cannot register ${param1} in the scope ${this.name}`);
         }
 
 

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

@@ -84,7 +84,6 @@ export class A_Stage {
                         return this.feature;
 
                     return scope
-                        .merge(A_Context.scope(this.feature))
                         .resolve(arg.target)
                 })
             )
@@ -119,7 +118,7 @@ export class A_Stage {
         // TODO: probably would be better to do it another way. let's think about it
         const instance = component instanceof A_Container
             ? component
-            : A_Context.scope(this.feature).resolve(component);
+            : this.feature.Scope.resolve(component);
 
         if (!instance)
             throw new Error(`Unable to resolve component ${component.name}`);
@@ -161,6 +160,9 @@ export class A_Stage {
         scope: A_Scope = new A_Scope({}, {}),
         params?: Partial<A_TYPES__A_StageStepProcessingExtraParams>
     ): Promise<void> {
+
+        scope = scope.inherit(this.feature.Scope);
+
         if (!this.processed)
             this.processed = new Promise<void>(
                 async (resolve, reject) => {