@adaas/a-concept 0.2.6 → 0.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaas/a-concept",
-  "version": "0.2.6",
+  "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-Feature/A-Feature.class.ts

@@ -375,11 +375,11 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
 
             // Convert iterator to array to get all stages
             const stages = Array.from(this);
-            
+
             return this.processStagesSequentially(stages, scope, 0);
 
         } catch (error) {
-            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,
@@ -392,11 +392,16 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
      * Process stages one by one, ensuring each stage completes before starting the next
      */
     private processStagesSequentially(
-        stages: A_Stage[], 
-        scope: A_Scope | undefined, 
+        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();
@@ -408,22 +413,28 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
 
             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
-                    }));
-                });
+                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) {
-            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,
@@ -455,19 +466,24 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
     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
      */
-    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;
 
@@ -475,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;
     }
 
 
@@ -573,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/tests/A-Feature.test.ts

@@ -591,22 +591,21 @@ describe('A-Feature tests', () => {
             ]
         });
 
-        feature.process();
-
-        await new Promise<void>(async (resolve) => {
-            setTimeout(() => {
-                feature.interrupt();
-            }, 1000);
-
-
-            setTimeout(() => {
-                expect(feature.state).toBe(A_TYPES__FeatureState.INTERRUPTED);
-                expect(executionOrder).toEqual(['feature1', 'feature2']);
-
-                resolve();
-
-            }, 3000);
-        });
+        await Promise.all([
+            feature.process(),
+            new Promise<void>(async (resolve) => {
+                setTimeout(() => {
+                    feature.interrupt();
+                    resolve();
+                }, 800);
+            }),
+            new Promise<void>(async (resolve) => {
+                setTimeout(() => {
+                    expect(feature.state).toBe(A_TYPES__FeatureState.INTERRUPTED);
+                    resolve();
+                }, 1000);
+            })
+        ]);
 
     }, 5000);
     it('Should allow to use extension if only parent class provided', async () => {
@@ -868,4 +867,171 @@ describe('A-Feature tests', () => {
         ]);
 
     })
+    it('Should throw a Sync error  when executed sync', async () => {
+
+        const resultChain: string[] = [];
+
+
+        class ChildComponent_A extends A_Component {
+            @A_Feature.Extend({
+                name: 'testFeature',
+            })
+            test1() {
+                resultChain.push('ChildComponent_A.test');
+                throw new A_Error('Deliberate Sync Error in test1');
+            }
+        }
+
+        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] });
+
+        try {
+            testScope.resolve(ChildComponent_A)!.call('testFeature');
+        } catch (error) {
+            expect(error).toBeInstanceOf(A_Error);
+            expect((error as A_Error).originalError).toBeInstanceOf(A_Error)
+            expect((error as A_Error).originalError.message).toBe('Deliberate Sync Error in test1');
+        }
+
+        expect(resultChain).toEqual([
+            'ChildComponent_A.test'
+        ]);
+        const feature = new A_Feature({
+            name: 'testFeature',
+            component: testScope.resolve(ChildComponent_A)!,
+        })
+
+        try {
+            feature.process();
+        } catch (error) {
+            expect(error).toBeInstanceOf(A_Error);
+            expect((error as A_Error).originalError).toBeInstanceOf(A_Error)
+            expect((error as A_Error).originalError.message).toBe('Deliberate Sync Error in test1');
+        }
+
+        expect(feature.state).toBe(A_TYPES__FeatureState.FAILED);
+
+        expect(resultChain).toEqual([
+            'ChildComponent_A.test',
+            'ChildComponent_A.test'
+        ]);
+    })
+    it('Should throw an Async error when executed async', 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, reject) => {
+                    setTimeout(() => {
+                        reject(new A_Error('Deliberate Async Error in test1'));
+                    }, 2000);
+                });
+            }
+        }
+
+        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] });
+        try {
+            await Promise.all([
+                new Promise<void>(async (resolve) => {
+                    setTimeout(() => {
+                        resultChain.push('feature3');
+
+                        resolve();
+                    }, 1000);
+                }),
+                testScope.resolve(ChildComponent_A)!.call('testFeature')
+            ]);
+
+        } catch (error) {
+            expect(error).toBeInstanceOf(A_Error);
+            expect((error as A_Error).originalError).toBeInstanceOf(A_Error)
+            expect((error as A_Error).originalError.message).toBe('Deliberate Async Error in test1');
+        }
+        expect(resultChain).toEqual([
+            'ChildComponent_A.test',
+            'feature3'
+        ]);
+
+        const feature = new A_Feature({
+            name: 'testFeature',
+            component: testScope.resolve(ChildComponent_A)!,
+        })
+
+        try {
+            await feature.process();
+        } catch (error) {
+            expect(error).toBeInstanceOf(A_Error);
+            expect((error as A_Error).originalError).toBeInstanceOf(A_Error)
+            expect((error as A_Error).originalError.message).toBe('Deliberate Async Error in test1');
+        }
+
+        expect(feature.state).toBe(A_TYPES__FeatureState.FAILED);
+
+        expect(resultChain).toEqual([
+            'ChildComponent_A.test',
+            'feature3',
+            'ChildComponent_A.test'
+        ]);
+    })
+
+    it('Should throw an Async error when executed async and error in method', async () => {
+
+        const resultChain: string[] = [];
+
+        class ChildComponent_A extends A_Component {
+            @A_Feature.Extend({
+                name: 'testFeature',
+            })
+            async test1() {
+                resultChain.push('ChildComponent_A.test');
+
+                throw new A_Error('Deliberate Async Error in test1');
+            }
+        }
+
+        const testScope = new A_Scope({ name: 'TestScope', components: [ChildComponent_A] });
+
+        const feature = new A_Feature({
+            name: 'testFeature',
+            component: testScope.resolve(ChildComponent_A)!,
+        })
+
+        try {
+            await feature.process();
+        } catch (error) {
+            expect(error).toBeInstanceOf(A_Error);
+            expect((error as A_Error).originalError).toBeInstanceOf(A_Error)
+            expect((error as A_Error).originalError.message).toBe('Deliberate Async Error in test1');
+        }
+
+        expect(feature.state).toBe(A_TYPES__FeatureState.FAILED);
+
+        expect(resultChain).toEqual([
+            'ChildComponent_A.test'
+        ]);
+    })
 });