@adaas/a-concept 0.2.6 → 0.2.8

package/package.json

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

@@ -1814,6 +1814,13 @@ export class A_Scope<
                 this._components.delete(param1.constructor as _ComponentType[number]);
                 A_Context.deregister(param1);
 
+                const ctor = param1.constructor as _ComponentType[number];
+
+                const hasComponent = this._components.has(ctor);
+                if (!hasComponent) {
+                    this.allowedComponents.delete(ctor);
+                }
+
                 break;
             }
             // 3) In case when it's a A-Entity instance
@@ -1821,14 +1828,28 @@ export class A_Scope<
 
                 this._entities.delete(param1.aseid.toString());
                 A_Context.deregister(param1);
+
+                const ctor = param1.constructor as _EntityType[number];
+
+                const hasEntity = Array.from(this._entities.values()).some(entity => entity instanceof ctor);
+                if (!hasEntity) {
+                    this.allowedEntities.delete(ctor);
+                }
+
                 break;
             }
             // 4) In case when it's a A-Fragment instance
             case A_TypeGuards.isFragmentInstance(param1): {
-
                 this._fragments.delete(param1.constructor as A_TYPES__Fragment_Constructor<_FragmentType[number]>);
                 A_Context.deregister(param1);
 
+                const ctor = param1.constructor as A_TYPES__Fragment_Constructor<_FragmentType[number]>;
+
+                const hasFragment = Array.from(this._fragments.values()).some(fragment => fragment instanceof ctor);
+                if (!hasFragment) {
+                    this.allowedFragments.delete(ctor);
+                }
+
                 break;
             }
             // 5) In case when it's a A-Error instance
@@ -1836,6 +1857,14 @@ export class A_Scope<
 
                 this._errors.delete(param1.code);
                 A_Context.deregister(param1);
+
+                const ctor = param1.constructor as _ErrorType[number];
+
+                const hasError = Array.from(this._errors.values()).some(error => error instanceof ctor);
+                if (!hasError) {
+                    this.allowedErrors.delete(ctor);
+                }
+
                 break;
             }
 
@@ -1850,16 +1879,40 @@ export class A_Scope<
             // 8) In case when it's a A-Fragment constructor
             case A_TypeGuards.isFragmentConstructor(param1): {
                 this.allowedFragments.delete(param1 as A_TYPES__Fragment_Constructor<_FragmentType[number]>);
+                // and then deregister all instances of this fragment
+                Array.from(this._fragments.entries()).forEach(([ctor, instance]) => {
+                    if (A_CommonHelper.isInheritedFrom(ctor, param1)) {
+                        this._fragments.delete(ctor);
+                        A_Context.deregister(instance);
+                    }
+                });
+
                 break;
             }
             // 9) In case when it's a A-Entity constructor
             case A_TypeGuards.isEntityConstructor(param1): {
                 this.allowedEntities.delete(param1 as _EntityType[number]);
+                //  and then deregister all instances of this entity
+                Array.from(this._entities.entries()).forEach(([aseid, instance]) => {
+                    if (A_CommonHelper.isInheritedFrom(instance.constructor, param1)) {
+                        this._entities.delete(aseid);
+                        A_Context.deregister(instance);
+                    }
+                });
+
                 break;
             }
             // 10) In case when it's a A-Error constructor
             case A_TypeGuards.isErrorConstructor(param1): {
                 this.allowedErrors.delete(param1 as _ErrorType[number]);
+                // and then deregister all instances of this error
+                Array.from(this._errors.entries()).forEach(([code, instance]) => {
+                    if (A_CommonHelper.isInheritedFrom(instance.constructor, param1)) {
+                        this._errors.delete(code);
+                        A_Context.deregister(instance);
+                    }
+                });
+
                 break;
             }
 
@@ -1875,6 +1928,7 @@ export class A_Scope<
                     `Cannot deregister ${componentName} from the scope ${this.name}`
                 );
         }
+
     }
 
     /**

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

package/tests/A-Scope.test.ts

@@ -705,4 +705,109 @@ describe('A-Scope tests', () => {
         expect(resolvedA).toBeInstanceOf(MyEntity_B);
         expect(resolvedA?.name).toBe('Entity1');
     });
+
+    it('Should deregister entities properly', async () => {
+
+        class MyEntity extends A_Entity { }
+
+        class MyFragment extends A_Fragment { }
+
+        class MyComponent extends A_Component { }
+
+        const scope = new A_Scope({ name: 'TestScope' });
+
+
+
+        const entity = new MyEntity();
+        const fragment = new MyFragment();
+
+        scope.register(entity);
+        scope.register(fragment);
+        scope.register(MyComponent);
+
+        expect(scope.has(MyEntity)).toBe(true);
+        expect(scope.has(MyFragment)).toBe(true);
+        expect(scope.has(MyComponent)).toBe(true);
+
+        scope.deregister(entity);
+        scope.deregister(fragment);
+        scope.deregister(MyComponent);
+
+        expect(scope.has(MyEntity)).toBe(false);
+        expect(scope.has(MyFragment)).toBe(false);
+        expect(scope.has(MyComponent)).toBe(false);
+    });
+
+    it('Should deregister all entities by class', async () => {
+
+        class BaseEntity extends A_Entity { }
+
+        class MyEntityA extends A_Entity { }
+        class MyEntityB extends BaseEntity { }
+
+
+        const scope = new A_Scope({ name: 'TestScope' });
+
+
+
+        const entityA1 = new MyEntityA();
+        const entityA2 = new MyEntityA();
+        const entityB1 = new MyEntityB();
+
+        scope.register(entityA1);
+        scope.register(entityA2);
+        scope.register(entityB1);
+
+        expect(scope.resolveAll(MyEntityA).length).toBe(2);
+        expect(scope.resolveAll(BaseEntity).length).toBe(1);
+
+        scope.deregister(MyEntityA);
+
+        expect(scope.resolveAll(MyEntityA).length).toBe(0);
+        expect(scope.resolveAll(BaseEntity).length).toBe(1);
+
+        const entityB2 = new MyEntityB();
+        scope.register(entityB2);
+
+        expect(scope.resolveAll(BaseEntity).length).toBe(2);
+
+        scope.deregister(BaseEntity);
+
+        expect(scope.resolveAll(BaseEntity).length).toBe(0);
+    });
+    it('Should register/deregister fragments with the same names', async () => {
+
+        class MyFragment extends A_Fragment {
+
+            array: string[] = [];
+
+            constructor(name: string) {
+                super({ name });
+            }
+        }
+
+        const scope = new A_Scope({ name: 'TestScope' });
+
+        const fragmentA1 = new MyFragment('fragmentA');
+
+        scope.register(fragmentA1);
+
+        expect(scope.has(MyFragment)).toBe(true);
+        expect(scope.resolve(MyFragment)).toBe(fragmentA1);
+
+        scope.deregister(fragmentA1);
+
+        fragmentA1.array.push('newData');
+
+
+        expect(scope.has(MyFragment)).toBe(false);
+
+        const fragmentA2 = new MyFragment('fragmentA');
+
+        scope.register(fragmentA2);
+
+        expect(scope.has(MyFragment)).toBe(true);
+        expect(scope.resolve(MyFragment)).toBe(fragmentA2);
+        expect(fragmentA2.array.length).toBe(0);
+    });
 });