@adaas/a-concept 0.1.42 → 0.1.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaas/a-concept",
-  "version": "0.1.42",
+  "version": "0.1.44",
   "description": "A-Concept is a framework to build new Applications within or outside the ADAAS ecosystem. This framework is designed to be modular structure regardless environment and program goal.",
   "license": "Apache-2.0",
   "main": "./dist/index.cjs",

package/src/global/A-Error/A_Error.class.ts

@@ -157,11 +157,15 @@ export class A_Error<
                 super(param1.message);
                 break;
 
-            case A_TypeGuards.isConstructorType<_ConstructorType>(param1) && 'description' in param1:
+            case A_TypeGuards.isErrorSerializedType<_SerializedType>(param1):
+                super(param1.message);
+                break;
+
+            case A_TypeGuards.isErrorConstructorType<_ConstructorType>(param1) && 'description' in param1:
                 super(`[${param1.title}]: ${param1.description}`);
                 break;
 
-            case A_TypeGuards.isConstructorType<_ConstructorType>(param1) && !('description' in param1):
+            case A_TypeGuards.isErrorConstructorType<_ConstructorType>(param1) && !('description' in param1):
                 super(param1.title);
                 break;
 
@@ -305,6 +309,7 @@ export class A_Error<
         param2?: string
     ): (param1: any, param2: any) => void | (() => void) {
         switch (true) {
+
             case A_TypeGuards.isString(param1) && !param2:
                 return this.fromMessage;
 
@@ -314,13 +319,13 @@ export class A_Error<
             case param1 instanceof Error:
                 return this.fromError;
 
+            case A_TypeGuards.isErrorSerializedType<_SerializedType>(param1):
+                return this.fromJSON;
 
-            case A_TypeGuards.isConstructorType<_ConstructorType>(param1):
+            case A_TypeGuards.isErrorConstructorType<_ConstructorType>(param1):
                 return this.fromConstructor;
 
             default: {
-                console.log('INVALID PARAMS PROVIDED TO A_ERROR CONSTRUCTOR: ', param1);
-
                 throw new A_Error(
                     A_CONSTANTS__ERROR_CODES.VALIDATION_ERROR,
                     'Invalid parameters provided to A_Error constructor'
@@ -365,6 +370,23 @@ export class A_Error<
         this._link = undefined;
         this._originalError = undefined;
     }
+    /**
+     * Initializes the A_Error instance from a serialized object.
+     * 
+     * @param serialized
+     */
+    protected fromJSON(serialized: _SerializedType): void {
+        this._aseid = new ASEID(serialized.aseid);
+        super.message = serialized.message;
+        this._title = serialized.title;
+        this._code = serialized.code;
+        this._scope = serialized.scope;
+        this._description = serialized.description;
+        // Note: originalError is deserialized as message only
+        this._originalError = serialized.originalError ? new A_Error(serialized.originalError) : undefined;
+        this._link = serialized.link;
+    }
+
 
 
     fromTitle(title: string, description: string): void {
@@ -404,7 +426,7 @@ export class A_Error<
 
         this._description = params.description;
         this._link = params.link;
-        
+
         // Handle originalError: if it's an A_Error, we should trace back to the root cause
         // to avoid infinite nesting of A_Error instances
         if (params.originalError instanceof A_Error) {

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

@@ -149,8 +149,14 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
      */
     get isDone(): boolean {
         return !this.stage
-            || this._index >= this._stages.length
-            || this.state === A_TYPES__FeatureState.COMPLETED
+            || this._index >= this._stages.length;
+    }
+    /**
+     * Indicates whether the feature has been processed (completed, failed, or interrupted)
+     */
+    get isProcessed(): boolean {
+        return this.state === A_TYPES__FeatureState.COMPLETED
+            || this.state === A_TYPES__FeatureState.FAILED
             || this.state === A_TYPES__FeatureState.INTERRUPTED;
     }
     /**
@@ -361,7 +367,7 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
                 scope.inherit(A_Context.scope(this));
 
 
-            if (this.isDone)
+            if (this.isProcessed)
                 return;
 
             this._state = A_TYPES__FeatureState.PROCESSING;
@@ -403,7 +409,7 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
      * @returns 
      */
     async completed(): Promise<void> {
-        if (this.isDone) return;
+        if (this.isProcessed) return;
 
 
         this._state = A_TYPES__FeatureState.COMPLETED;
@@ -417,7 +423,7 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
      * @param error 
      */
     async failed(error: A_FeatureError) {
-        if (this.isDone) return;
+        if (this.isProcessed) return;
 
         this._state = A_TYPES__FeatureState.FAILED;
 
@@ -439,7 +445,7 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
          */
         reason?: string | A_StageError | Error
     ) {
-        if (this.isDone) return;
+        if (this.isProcessed) return;
 
         this._state = A_TYPES__FeatureState.INTERRUPTED;
 

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

@@ -274,7 +274,6 @@ export class A_Stage {
 
                         this.failed(wrappedError);
 
-
                         if (this._definition.throwOnError) {
                             return resolve();
                         } else {

package/src/helpers/A_TypeGuards.helper.ts

@@ -5,7 +5,8 @@ import {
 } from "../global/A-Feature/A-Feature.types";
 import {
     A_TYPES__Error_Constructor,
-    A_TYPES__Error_Init
+    A_TYPES__Error_Init,
+    A_TYPES__Error_Serialized
 } from "../global/A-Error/A_Error.types";
 import { A_Component } from "../global/A-Component/A-Component.class";
 import { A_ComponentMeta } from "../global/A-Component/A-Component.meta";
@@ -27,6 +28,7 @@ import { A_CommonHelper } from "./A_Common.helper";
 import { A_TYPES__AbstractionAvailableComponents } from "../global/A-Abstraction/A-Abstraction.types";
 import { A_TYPES__Scope_Constructor, A_TYPES__ScopeLinkedComponents, A_TYPES__ScopeLinkedConstructors } from "../global/A-Scope/A-Scope.types";
 import { A_TYPES__InjectableTargets } from "../global/A-Inject/A-Inject.types";
+import { ASEID } from "../global/ASEID/ASEID.class";
 
 
 
@@ -332,7 +334,12 @@ export class A_TypeGuards {
      * @param param 
      * @returns 
      */
-    static isConstructorType<T extends A_TYPES__Error_Init>(param: any): param is T {
+    static isErrorConstructorType<T extends A_TYPES__Error_Init>(param: any): param is T {
         return !!param && A_TypeGuards.isObject(param) && !(param instanceof Error) && "title" in param;
     }
+
+
+    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);
+    }
 }

package/tests/A-Feature.test.ts

@@ -5,7 +5,7 @@ import { A_Scope } from "@adaas/a-concept/global/A-Scope/A-Scope.class";
 import { A_Caller } from '@adaas/a-concept/global/A-Caller/A_Caller.class';
 import { A_Context } from '@adaas/a-concept/global/A-Context/A-Context.class';
 import { A_TYPES__ComponentMetaKey } from '@adaas/a-concept/global/A-Component/A-Component.constants';
-import { A_TYPES__FeatureState } from "../src";
+import { A_Error, A_TYPES__FeatureState } from "../src";
 
 jest.retryTimes(0);
 
@@ -92,6 +92,67 @@ describe('A-Feature tests', () => {
         expect(myComponent.sum).toBe(2);
 
     });
+
+
+    it('Should fail execution when error occurs', async () => {
+        // 1) create a base component with some feature
+        class MyExtendedComponent extends A_Component {
+
+            async testHandler(
+                @A_Inject(A_Caller) caller: MyComponent
+            ) {
+                throw new Error('Deliberate error in testHandler');
+            }
+        }
+
+        // 2) create a custom component with a defined template feature
+        class MyComponent extends A_Component {
+            sum: number = 0;
+
+            @A_Feature.Define({
+                invoke: true,
+                template: [{
+                    name: 'MyExtendedComponent.testHandler',
+                    component: MyExtendedComponent,
+                    handler: 'testHandler',
+                    behavior: 'sync',
+                    before: '',
+                    after: ''
+                },
+                {
+                    name: 'MyExtendedComponent.testHandler',
+                    component: MyExtendedComponent,
+                    handler: 'testHandler'
+                }]
+            })
+            async testHandler() { }
+        }
+
+
+        // 3) create a running scope 
+        const scope = new A_Scope({ name: 'TestScope' });
+        scope.register(MyExtendedComponent);
+        scope.register(MyComponent);
+
+        // 4) create an instance of the component from the scope
+        const myComponent = scope.resolve(MyComponent)!;
+        expect(myComponent).toBeInstanceOf(MyComponent);
+        expect(myComponent.sum).toBe(0);
+
+        // 5) call the feature caller to execute the feature
+        try {
+            await myComponent.testHandler();
+
+        } catch (error) {
+            expect(error).toBeInstanceOf(A_Error);
+            expect((error as A_Error).originalError).toBeInstanceOf(Error);
+            expect((error as A_Error).originalError.message).toBe('Deliberate error in testHandler');
+        }
+
+        // 6) check the results
+        expect(myComponent.sum).toBe(0);
+
+    });
     it('Should be possible to execute a feature with steps as a template on the component with string component declaration', async () => {
         // 1) create a base component with some feature
         class MyExtendedComponent2 extends A_Component {
@@ -407,7 +468,7 @@ describe('A-Feature tests', () => {
 
 
         // 2) create a running scope 
-        const scope = new A_Scope({ name: 'TestScope' , components: [ComponentA, ComponentB] });
+        const scope = new A_Scope({ name: 'TestScope', components: [ComponentA, ComponentB] });
 
 
         // 3) create an instance of the component from the scope