@adaas/a-concept 0.0.39 → 0.0.41

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

@@ -93,6 +93,16 @@ export class A_Meta<
     }
 
 
+    /**
+     * Method to get the size of the map
+     * 
+     * @returns 
+     */
+    size(): number {
+        return this.meta.size;
+    }
+
+
     /**
      * This method is needed to convert the key to a regular expression and cover cases like: 
      * 

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

@@ -3,8 +3,8 @@ import { A_Context } from "../A-Context/A-Context.class";
 import { A_Feature } from "../A-Feature/A-Feature.class";
 import { A_TYPES__A_Stage_JSON, A_TYPES__A_Stage_Status, A_TYPES__A_StageStep, A_TYPES__A_StageStepProcessingExtraParams } from "./A-Stage.types";
 import { A_Container } from "../A-Container/A-Container.class";
-import { A_TYPES__ScopeConstructor } from "../A-Scope/A-Scope.types";
 import { A_Scope } from "../A-Scope/A-Scope.class";
+import { A_StageError } from "./A-Stage.error";
 
 
 /**
@@ -16,12 +16,24 @@ import { A_Scope } from "../A-Scope/A-Scope.class";
  */
 export class A_Stage {
 
+    readonly name: string = 'A_Stage';
 
+    private readonly feature!: A_Feature;
+    private readonly _steps!: A_TYPES__A_StageStep[];
 
     constructor(
-        private feature: A_Feature,
-        private _steps: A_TYPES__A_StageStep[] = []
+        feature: A_Feature,
+        _steps: A_TYPES__A_StageStep[] = []
     ) {
+        this.feature = feature;
+        this._steps = _steps;
+        this.name = `${this.feature.name}::a-stage:[sync:${this
+            .syncSteps
+            .map(s => s.component.name + '.' + s.handler)
+            .join(' -> ')}][async:${this
+                .asyncSteps
+                .map(s => s.component.name + '.' + s.handler)
+                .join(' -> ')}]`;
 
     }
 
@@ -54,10 +66,10 @@ export class A_Stage {
     get asyncSteps(): A_TYPES__A_StageStep[] {
         return this._steps.filter(step => step.behavior === 'async');
     }
-    
+
     get syncSteps(): A_TYPES__A_StageStep[] {
         return this._steps.filter(step => step.behavior === 'sync');
-    }   
+    }
 
 
     /**
@@ -84,7 +96,6 @@ export class A_Stage {
                         return this.feature;
 
                     return scope
-                        .merge(A_Context.scope(this.feature))
                         .resolve(arg.target)
                 })
             )
@@ -119,7 +130,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}`);
@@ -140,12 +151,12 @@ export class A_Stage {
      */
     protected async callStepHandler(
         step: A_TYPES__A_StageStep,
-        scope: A_Scope 
+        scope: A_Scope
     ) {
         const instance = await this.getStepInstance(step);
         const callArgs = await this.getStepArgs(step, scope);
 
-        return instance[step.handler](...callArgs);
+        return await instance[step.handler](...callArgs);
     }
 
 
@@ -161,6 +172,12 @@ export class A_Stage {
         scope: A_Scope = new A_Scope({}, {}),
         params?: Partial<A_TYPES__A_StageStepProcessingExtraParams>
     ): Promise<void> {
+
+        scope = scope.inherit(this.feature.Scope);
+
+
+        console.log(' -> Init stage processing:', this.name);
+
         if (!this.processed)
             this.processed = new Promise<void>(
                 async (resolve, reject) => {
@@ -175,7 +192,7 @@ export class A_Stage {
                         const asyncSteps = this.asyncSteps.filter(params?.filter || (() => true));
 
                         // Run sync _steps
-                        await Promise 
+                        await Promise
                             .all([
 
                                 // Run async _steps that are independent of each other
@@ -186,11 +203,16 @@ export class A_Stage {
                                     async (r, j) => {
                                         try {
                                             for (const step of syncSteps) {
+                                                console.log(' - -> Processing stage step:', step.handler, ' with Regexp: ', step.name);
+
                                                 await this.callStepHandler(step, scope);
+
+                                                console.log(' - -> Finished processing stage step:', step.handler);
                                             }
 
                                             return r();
                                         } catch (error) {
+
                                             return j(error);
                                         }
                                     }
@@ -199,6 +221,7 @@ export class A_Stage {
 
                         this.completed();
 
+                        console.log(' -> Finished stage processing:', this.name);
                         return resolve();
 
                     } catch (error) {
@@ -241,7 +264,7 @@ export class A_Stage {
     ) {
         this.status = A_TYPES__A_Stage_Status.FAILED;
 
-        this.feature.failed(error);
+        this.feature.failed(new A_StageError(error));
     }
 
 

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

@@ -0,0 +1,9 @@
+import { A_Error } from "@adaas/a-utils";
+
+
+export class A_StageError extends A_Error {
+
+
+    
+
+}

package/src/helpers/StepsManager.class.ts

@@ -82,7 +82,7 @@ export class StepsManager {
             if (!this.visited.has(this.ID(entity))) this.visit(this.ID(entity));
         });
 
-        const stages: A_Stage[] = [];
+        const stages: A_TmpStage[] = [];
 
         // Map sorted names back to entity objects
         this.sortedEntities
@@ -96,13 +96,73 @@ export class StepsManager {
 
 
                 if (!stage) {
-                    stage = new A_Stage(feature);
+                    stage = new A_TmpStage();
                     stages.push(stage);
                 }
 
                 stage.add(step);
             });
 
-        return stages;
+        return stages.map(stage => new A_Stage(feature, stage.steps) );
+    }
+}
+
+
+
+
+
+export class A_TmpStage {
+
+    readonly name: string = 'A_TmpStage';
+
+    private readonly _steps!: A_TYPES__A_StageStep[];
+
+    constructor(
+        _steps: A_TYPES__A_StageStep[] = []
+    ) {
+        this._steps = _steps;
+    }
+
+
+    get before(): string[] {
+        return this._steps.reduce((acc, step) => ([
+            ...acc,
+            ...step.before
+        ]), [] as string[]);
+    }
+
+    get after(): string[] {
+        return this._steps.reduce((acc, step) => ([
+            ...acc,
+            ...step.after
+        ]), [] as string[]);
+    }
+
+    get steps(): A_TYPES__A_StageStep[] {
+        return this._steps;
+    }
+
+
+    get asyncSteps(): A_TYPES__A_StageStep[] {
+        return this._steps.filter(step => step.behavior === 'async');
+    }
+
+    get syncSteps(): A_TYPES__A_StageStep[] {
+        return this._steps.filter(step => step.behavior === 'sync');
+    }
+
+
+    /**
+     * Adds a step to the stage
+     * 
+     * @param step 
+     * @returns 
+     */
+    add(
+        step: A_TYPES__A_StageStep
+    ): this {
+        this._steps.push(step);
+
+        return this;
     }
 }