@adaas/a-concept 0.2.5 → 0.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaas/a-concept",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "description": "A-Concept is a framework of the new generation that is tailored to use AI, enabling developers to create AI-powered applications with ease. It provides a structured approach to building, managing, and deploying AI-driven solutions.",
   "license": "Apache-2.0",
   "main": "./dist/index.cjs",

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

@@ -29,7 +29,7 @@ export class A_Component {
      * @param scope  - the scope in which to call the feature
      * @returns  - void
      */
-    async call(
+    call(
         /**
          * Name of the feature to call
          */
@@ -38,13 +38,13 @@ export class A_Component {
          * Scope in which the feature will be executed
          */
         scope?: A_Scope
-    ) {
+    ): Promise<any> | void {
         const newFeature = new A_Feature({
             name: feature,
             component: this
         });
 
-        return await newFeature.process(scope);
+        return newFeature.process(scope);
     }
 }
 

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

@@ -355,13 +355,13 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
      * This method processes the feature by executing all the stages
      * 
      */
-    async process(
+    process(
         /**
          * Optional scope to be used to resolve the steps dependencies
          * If not provided, the scope of the caller component will be used
          */
         scope?: A_Scope,
-    ) {
+    ): Promise<void> | void {
         try {
             // It seems like this is a bad idea to enforce scope inheritance here
             // ---------------------------------------------------------------
@@ -373,20 +373,63 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
 
             this._state = A_TYPES__FeatureState.PROCESSING;
 
-            for (const stage of this) {
-                await stage.process(scope);
-            }
+            // Convert iterator to array to get all stages
+            const stages = Array.from(this);
+            
+            return this.processStagesSequentially(stages, scope, 0);
 
-            return await this.completed();
         } catch (error) {
-            return await this.failed(new A_FeatureError({
+            this.failed(new A_FeatureError({
                 title: A_FeatureError.FeatureProcessingError,
                 description: `An error occurred while processing the A-Feature: ${this.name}. Failed at stage: ${this.stage?.name || 'N/A'}.`,
                 stage: this.stage,
                 originalError: error
             }));
         }
+    }
+
+    /**
+     * Process stages one by one, ensuring each stage completes before starting the next
+     */
+    private processStagesSequentially(
+        stages: A_Stage[], 
+        scope: A_Scope | undefined, 
+        index: number
+    ): Promise<void> | void {
+        try {
+            // If we've processed all stages, complete the feature
+            if (index >= stages.length) {
+                this.completed();
+                return;
+            }
 
+            const stage = stages[index];
+            const result = stage.process(scope);
+
+            if (A_TypeGuards.isPromiseInstance(result)) {
+                // Async stage - return promise that processes remaining stages
+                return result.then(() => {
+                    return this.processStagesSequentially(stages, scope, index + 1);
+                }).catch(error => {
+                    this.failed(new A_FeatureError({
+                        title: A_FeatureError.FeatureProcessingError,
+                        description: `An error occurred while processing the A-Feature: ${this.name}. Failed at stage: ${stage.name}.`,
+                        stage: stage,
+                        originalError: error
+                    }));
+                });
+            } else {
+                // Sync stage - continue to next stage immediately
+                return this.processStagesSequentially(stages, scope, index + 1);
+            }
+        } catch (error) {
+            this.failed(new A_FeatureError({
+                title: A_FeatureError.FeatureProcessingError,
+                description: `An error occurred while processing the A-Feature: ${this.name}. Failed at stage: ${this.stage?.name || 'N/A'}.`,
+                stage: this.stage,
+                originalError: error
+            }));
+        }
     }
     /**
      * This method moves the feature to the next stage
@@ -409,7 +452,7 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
      * @param result 
      * @returns 
      */
-    async completed(): Promise<void> {
+    completed(): void {
         if (this.isProcessed) return;
 
 
@@ -423,7 +466,7 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
      * 
      * @param error 
      */
-    async failed(error: A_FeatureError) {
+    failed(error: A_FeatureError) {
         if (this.isProcessed) return;
 
         this._state = A_TYPES__FeatureState.FAILED;

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

@@ -35,11 +35,6 @@ export class A_Stage {
      */
     private _status: A_TYPES__A_Stage_Status = A_TYPES__A_Stage_Status.INITIALIZED;
 
-    /**
-     * Promise that will be resolved when the stage is Processed
-     */
-    private _processed: Promise<void> | undefined;
-
 
     /**
      * A_Stage is a callable A_Function within A_Feature that should be run with specific parameters.
@@ -106,7 +101,7 @@ export class A_Stage {
      * @param step 
      * @returns 
      */
-    protected async getStepArgs(
+    protected getStepArgs(
         scope: A_Scope,
         step: A_TYPES__A_StageStep
     ) {
@@ -114,24 +109,22 @@ export class A_Stage {
             (step.dependency.target as A_TYPES__Container_Constructor | A_TYPES__Component_Constructor)
             || scope.resolveConstructor(step.dependency.name);
 
-        return Promise
-            .all(A_Context
-                .meta(resolverConstructor)
-                .injections(step.handler)
-                .map(async dependency => {
-                    switch (true) {
-                        case A_TypeGuards.isCallerConstructor(dependency.target):
-                            return this._feature.caller.component;
+        return A_Context
+            .meta(resolverConstructor)
+            .injections(step.handler)
+            .map(dependency => {
+                switch (true) {
+                    case A_TypeGuards.isCallerConstructor(dependency.target):
+                        return this._feature.caller.component;
 
-                        case A_TypeGuards.isFeatureConstructor(dependency.target):
-                            return this._feature;
+                    case A_TypeGuards.isFeatureConstructor(dependency.target):
+                        return this._feature;
 
-                        default: {
-                            return scope.resolve(dependency);
-                        }
+                    default: {
+                        return scope.resolve(dependency);
                     }
-                })
-            )
+                }
+            })
     }
 
 
@@ -174,17 +167,23 @@ export class A_Stage {
      * @param step 
      * @returns 
      */
-    protected async callStepHandler(
+    protected callStepHandler(
         step: A_TYPES__A_StageStep,
         scope: A_Scope
-    ) {
+    ): {
+        handler: Function,
+        params: any[]
+    } {
         // 1) Resolve component
-        const component = await this.getStepComponent(scope, step);
+        const component = this.getStepComponent(scope, step);
         // 2) Resolve arguments
-        const callArgs = await this.getStepArgs(scope, step);
+        const callArgs = this.getStepArgs(scope, step);
 
         // 3) Call handler
-        return await component[step.handler](...callArgs);
+        return {
+            handler: component[step.handler].bind(component),
+            params: callArgs
+        }
     }
 
 
@@ -198,48 +197,51 @@ export class A_Stage {
      * 
      * @param scope - Scope to be used to resolve the steps dependencies
      */
-    async process(
+     process(
         /**
          * Scope to be used to resolve the steps dependencies
          */
         scope?: A_Scope,
-    ): Promise<void> {
+    ): Promise<void> | void {
 
         const targetScope = A_TypeGuards.isScopeInstance(scope)
             ? scope
             : this._feature.scope;
 
-        if (!this._processed)
-            this._processed = new Promise<void>(
-                async (resolve, reject) => {
-                    try {
-                        this._status = A_TYPES__A_Stage_Status.PROCESSING;
-
-                        if (this._definition.behavior === 'sync') {
-                            // in case we have to wait for the result
-                            await this.callStepHandler(this._definition, targetScope);
-                        } else {
-                            // in case we don't have to wait for the result
-                            this.callStepHandler(this._definition, targetScope);
-                        }
+        if (!this.isProcessed) {
+            this._status = A_TYPES__A_Stage_Status.PROCESSING;
+
+            const { handler, params } = this.callStepHandler(this._definition, targetScope);
 
-                        this.completed();
+            const result = handler(...params);
 
-                        return resolve();
-                    } catch (error) {
-                        const wrappedError = new A_Error(error as any);
+            if (A_TypeGuards.isPromiseInstance(result)) {
 
-                        this.failed(wrappedError);
+                return new Promise<void>(
+                    async (resolve, reject) => {
+                        try {
+                            await result;
+
+                            this.completed();
 
-                        if (this._definition.throwOnError) {
                             return resolve();
-                        } else {
-                            return reject(wrappedError);
+                        } catch (error) {
+                            const wrappedError = new A_Error(error as any);
+
+                            this.failed(wrappedError);
+
+                            if (this._definition.throwOnError) {
+                                return resolve();
+                            } else {
+                                return reject(wrappedError);
+                            }
                         }
-                    }
-                });
+                    });
+            } else {
+                this.completed();
+            }
+        }
 
-        return this._processed;
     }
 
 

package/src/helpers/A_TypeGuards.helper.ts

@@ -367,4 +367,9 @@ export class A_TypeGuards {
     static isErrorSerializedType<T extends A_TYPES__Error_Serialized>(param: any): param is T {
         return !!param && A_TypeGuards.isObject(param) && !(param instanceof Error) && "aseid" in param && ASEID.isASEID(param.aseid);
     }
+
+
+    static isPromiseInstance<T>(value: any): value is Promise<T> {
+        return value instanceof Promise;
+    }
 }

package/tests/A-Abstraction.test.ts

@@ -334,8 +334,6 @@ describe('A-Abstraction Tests', () => {
 
         await concept.load();
 
-        console.log(executionOrder);
-
         expect(executionOrder).toEqual(['stepTwo']);
     });
 });

package/tests/A-Feature.test.ts

@@ -644,7 +644,7 @@ describe('A-Feature tests', () => {
         await baseEntity.test();
 
         expect(executionResults).toEqual(['testMethod']);
-        
+
         await myEntity.test();
 
         expect(executionResults).toEqual(['testMethod', 'testMethod']);
@@ -783,4 +783,89 @@ describe('A-Feature tests', () => {
         ]);
 
     })
+    it('Should execute Sync operations properly', async () => {
+
+        const resultChain: string[] = [];
+
+
+        class ChildComponent_A extends A_Component {
+            @A_Feature.Extend({
+                name: 'testFeature',
+            })
+            test1() {
+                resultChain.push('ChildComponent_A.test');
+            }
+        }
+
+        class ChildComponent_B extends A_Component {
+            @A_Feature.Extend({
+                name: 'testFeature',
+            })
+            test2() {
+                resultChain.push('ChildComponent_B.test');
+            }
+        }
+
+
+        const testScope = new A_Scope({ name: 'TestScope', components: [ChildComponent_A, ChildComponent_B] });
+
+        testScope.resolve(ChildComponent_A)!.call('testFeature');
+
+
+        expect(resultChain).toEqual([
+            'ChildComponent_A.test',
+            'ChildComponent_B.test'
+        ]);
+
+    })
+
+    it('Should execute Async operations properly', async () => {
+
+        const resultChain: string[] = [];
+
+
+        class ChildComponent_A extends A_Component {
+            @A_Feature.Extend({
+                name: 'testFeature',
+            })
+            async test1() {
+                resultChain.push('ChildComponent_A.test');
+
+                await new Promise<void>(async (resolve) => {
+                    setTimeout(() => {
+                        resolve();
+                    }, 3000);
+                });
+            }
+        }
+
+        class ChildComponent_B extends A_Component {
+            @A_Feature.Extend({
+                name: 'testFeature',
+            })
+            async test2() {
+                resultChain.push('ChildComponent_B.test');
+            }
+        }
+
+        const testScope = new A_Scope({ name: 'TestScope', components: [ChildComponent_A, ChildComponent_B] });
+
+        await Promise.all([
+            new Promise<void>(async (resolve) => {
+                setTimeout(() => {
+                    resultChain.push('feature3');
+
+                    resolve();
+                }, 2000);
+            }),
+            testScope.resolve(ChildComponent_A)!.call('testFeature')
+        ]);
+
+        expect(resultChain).toEqual([
+            'ChildComponent_A.test',
+            'feature3',
+            'ChildComponent_B.test'
+        ]);
+
+    })
 });