@adaas/a-concept 0.2.5 → 0.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaas/a-concept",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "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,74 @@ 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({
+            throw 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 {
+            // Check if feature has been interrupted before processing next stage
+            if (this.state === A_TYPES__FeatureState.INTERRUPTED) {
+                return;
+            }
+
+            // 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(() => {
+                        // Check for interruption after async stage completes
+                        if (this.state === A_TYPES__FeatureState.INTERRUPTED) {
+                            return;
+                        }
+                        return this.processStagesSequentially(stages, scope, index + 1);
+                    })
+                    .catch(error => {
+                        throw 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) {
+            throw 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,22 +463,27 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
      * @param result 
      * @returns 
      */
-    async completed(): Promise<void> {
+    completed(): void {
         if (this.isProcessed) return;
 
+        // Don't complete if interrupted
+        if (this.state === A_TYPES__FeatureState.INTERRUPTED) {
+            return;
+        }
 
         this._state = A_TYPES__FeatureState.COMPLETED;
 
         this.scope.destroy();
     }
     /**
-     * This method marks the feature as failed and throws an error
+     * This method marks the feature as failed and returns the error
      * Uses to mark the feature as failed
      * 
      * @param error 
+     * @returns The error that caused the failure
      */
-    async failed(error: A_FeatureError) {
-        if (this.isProcessed) return;
+    failed(error: A_FeatureError): A_FeatureError {
+        if (this.isProcessed) return this._error!;
 
         this._state = A_TYPES__FeatureState.FAILED;
 
@@ -432,45 +491,47 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
 
         this.scope.destroy();
 
-        throw this._error;
+        return this._error;
     }
     /**
-     * This method marks the feature as failed and throws an error
+     * This method marks the feature as interrupted and throws an error
      * Uses to interrupt or end the feature processing
      * 
      * @param error 
      */
-    async interrupt(
+    interrupt(
         /**
          * The reason of feature interruption
          */
         reason?: string | A_StageError | Error
-    ) {
-        if (this.isProcessed) return;
+    ): A_FeatureError {
+        if (this.isProcessed) return this._error!;
 
         this._state = A_TYPES__FeatureState.INTERRUPTED;
 
         switch (true) {
             case A_TypeGuards.isString(reason):
-                this._error = new A_FeatureError(A_FeatureError.Interruption, reason);
+                this._error = new A_FeatureError(A_FeatureError.Interruption, reason as string);
                 break;
 
             case A_TypeGuards.isErrorInstance(reason):
                 this._error = new A_FeatureError({
                     code: A_FeatureError.Interruption,
-                    title: reason.title,
-                    description: reason.description,
+                    title: (reason as any).title || 'Feature Interrupted',
+                    description: (reason as any).description || (reason as Error).message,
                     stage: this.stage,
                     originalError: reason
                 });
                 break;
 
             default:
+                this._error = new A_FeatureError(A_FeatureError.Interruption, 'Feature was interrupted');
                 break;
         }
 
-
         this.scope.destroy();
+        
+        return this._error;
     }
 
 
@@ -530,7 +591,17 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
         // create new caller for the chained feature
         feature._caller = this._caller;
 
-        return feature.process(featureScope);
+        const result = feature.process(featureScope);
+        
+        // If the chained feature processing returns a promise, ensure errors are propagated
+        if (A_TypeGuards.isPromiseInstance(result)) {
+            return result.catch(error => {
+                // Re-throw to ensure chained feature errors propagate to caller
+                throw error;
+            });
+        }
+        
+        return result;
     }
 
 

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']);
     });
 });