@adaas/a-concept 0.1.17 → 0.1.19

package/src/{helpers/A_StepsManager.class.ts → global/A-StepManager/A-StepManager.class.ts}

@@ -1,8 +1,8 @@
-import { A_Error } from "../global/A-Error/A_Error.class";
-import { A_Feature } from "../global/A-Feature/A-Feature.class";
-import { A_TYPES__FeatureDefineDecoratorTemplateItem } from "../global/A-Feature/A-Feature.types";
-import { A_Stage } from "../global/A-Stage/A-Stage.class";
-import { A_TYPES__A_StageStep } from "../global/A-Stage/A-Stage.types";
+import { A_Feature } from "../A-Feature/A-Feature.class";
+import { A_TYPES__FeatureDefineDecoratorTemplateItem } from "../A-Feature/A-Feature.types";
+import { A_Stage } from "../A-Stage/A-Stage.class";
+import { A_TYPES__A_StageStep } from "../A-Stage/A-Stage.types";
+import { A_StepManagerError } from "./A-StepManager.error";
 
 export class A_StepsManager {
 
@@ -13,6 +13,8 @@ export class A_StepsManager {
     public sortedEntities: string[];
 
 
+    private _isBuilt: boolean = false;
+
     constructor(entities: Array<A_TYPES__FeatureDefineDecoratorTemplateItem>) {
         this.entities = this.prepareSteps(entities);
 
@@ -29,10 +31,11 @@ export class A_StepsManager {
         return entities.map(step => {
             return {
                 ...step,
-                
+
                 behavior: step.behavior || 'sync',
                 before: step.before || [],
                 after: step.after || [],
+                throwOnError: false
             };
         });
     }
@@ -42,6 +45,8 @@ export class A_StepsManager {
     }
 
     private buildGraph() {
+        if (this._isBuilt) return;
+        this._isBuilt = true;
         // Initialize graph nodes
         this.entities.forEach(entity => this.graph.set(this.ID(entity), new Set()));
 
@@ -54,7 +59,7 @@ export class A_StepsManager {
             // If entity should execute before targets, then targets depend on entity
             // So we add edges: target -> entity (target depends on entity)
             before.forEach(dep => {
-                const targets = this.matchEntities(dep);
+                const targets = this.matchEntities(entityId, dep);
                 targets.forEach(target => {
                     if (!this.graph.has(target)) this.graph.set(target, new Set());
                     this.graph.get(target)!.add(entityId); // target depends on entity
@@ -65,7 +70,7 @@ export class A_StepsManager {
             // If entity should execute after sources, then entity depends on sources
             // So we add edges: entity -> source (entity depends on source)
             after.forEach(dep => {
-                const sources = this.matchEntities(dep);
+                const sources = this.matchEntities(entityId, dep);
 
                 sources.forEach(source => {
                     if (!this.graph.has(entityId)) this.graph.set(entityId, new Set());
@@ -76,28 +81,51 @@ export class A_StepsManager {
     }
 
     // Match entities by name or regex
-    private matchEntities(pattern: string): string[] {
-        const regex = new RegExp(`^${pattern}$`);
+    private matchEntities(entityId: string, pattern: string): string[] {
+        const regex = new RegExp(pattern);
+
         return this.entities
-            .filter(entity => regex.test(this.ID(entity)))
+            .filter(entity => regex.test(this.ID(entity)) && this.ID(entity) !== entityId)
             .map(entity => this.ID(entity));
     }
 
     // Topological sort with cycle detection
     private visit(node: string): void {
-        if (this.tempMark.has(node)) throw new A_Error("Circular dependency detected");
+        if (this.tempMark.has(node)) {
+            return;
+            // TODO: maybe we have to keep this error but only for partial cases
+            throw new A_StepManagerError(
+                A_StepManagerError.CircularDependencyError,
+                `Circular dependency detected involving step: ${node}. Make sure that your 'before' and 'after' dependencies do not create cycles.`
+            );
+        }
 
         if (!this.visited.has(node)) {
             this.tempMark.add(node);
+
+
             (this.graph.get(node) || []).forEach(neighbor => this.visit(neighbor));
             this.tempMark.delete(node);
             this.visited.add(node);
             this.sortedEntities.push(node);
+
+            // // Visit neighbors in stable order (preserving original order)
+            // const neighbors = Array.from(this.graph.get(node) || []);
+            // // neighbors.sort((a, b) => {
+            // //     const orderA = this.originalOrder.get(a) || 0;
+            // //     const orderB = this.originalOrder.get(b) || 0;
+            // //     return orderA - orderB;
+            // // });
+
+            // neighbors.forEach(neighbor => this.visit(neighbor));
+            // this.tempMark.delete(node);
+            // this.visited.add(node);
+            // this.sortedEntities.push(node);
         }
     }
 
-    // Sort the entities based on dependencies
-    toStages(feature: A_Feature): Array<A_Stage> {
+
+    toSortedArray(): Array<string> {
         this.buildGraph();
 
         // Start topological sort
@@ -105,87 +133,25 @@ export class A_StepsManager {
             if (!this.visited.has(this.ID(entity))) this.visit(this.ID(entity));
         });
 
-        const stages: A_TmpStage[] = [];
-
-        // Map sorted names back to entity objects
-        this.sortedEntities
-            .map(id => {
-                const step = this.entities.find(entity => this.ID(entity) === id)!;
-
-                let stage = stages.find(stage => {
-                    return stage.after.every(after => step.after.includes(after))
-                        && step.before.every(before => stage.after.includes(before));
-                });
-
-
-                if (!stage) {
-                    stage = new A_TmpStage();
-                    stages.push(stage);
-                }
-
-                stage.add(step);
-            });
-
-        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;
+        return this.sortedEntities;
     }
 
+    // Sort the entities based on dependencies
+    toStages(feature: A_Feature): Array<A_Stage> {
 
-    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[]);
-    }
+        const sortedNames = this.toSortedArray();
 
-    get steps(): A_TYPES__A_StageStep[] {
-        return this._steps;
-    }
 
+        // Map sorted names back to entity objects
+        return sortedNames
+            .map(id => {
+                const step = this.entities.find(entity => this.ID(entity) === id)!;
 
-    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');
+                return new A_Stage(feature, step);
+            });
     }
+}
 
 
-    /**
-     * Adds a step to the stage
-     * 
-     * @param step 
-     * @returns 
-     */
-    add(
-        step: A_TYPES__A_StageStep
-    ): this {
-        this._steps.push(step);
-
-        return this;
-    }
-}

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

@@ -0,0 +1,10 @@
+import { A_Error } from "../A-Error/A_Error.class";
+
+
+
+export class A_StepManagerError extends A_Error {
+
+
+    static readonly CircularDependencyError = 'A-StepManager Circular Dependency Error';
+
+}