@adaas/a-concept 0.1.53 → 0.1.54

package/package.json

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

@@ -474,6 +474,66 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
     }
 
 
+    /**
+     * Allows to chain the feature to another feature. 
+     * In this case the parent feature scope (if new not provided), stages, caller will be used.
+     * 
+     * [!] Note: Chained feature will use the same caller as the parent feature.
+     * 
+     * @param feature 
+     */
+    chain(
+        /**
+         * A Feature to be chained
+         */
+        feature: A_Feature,
+        /**
+         * Optional scope to be used for the chained feature.
+         */
+        scope?: A_Scope
+    )
+    chain<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__FeatureAvailableComponents>(
+        /**
+         * Component whose feature should be chained
+         */
+        component: A_TYPES__FeatureAvailableComponents,
+        /**
+         * A Feature Name to be chained
+         */
+        feature: string,
+        /**
+         * Optional scope to be used for the chained feature.
+         */
+        scope?: A_Scope
+    )
+    chain<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__FeatureAvailableComponents>(
+        param1: A_TYPES__FeatureAvailableComponents | A_Feature,
+        param2?: string | A_Scope,
+        param3?: A_Scope
+    ) {
+        let feature: A_Feature;
+        let scope: A_Scope | undefined;
+
+        if (param1 instanceof A_Feature) {
+            feature = param1;
+            scope = param2 instanceof A_Scope ? param2 : undefined;
+        } else {
+            feature = new A_Feature({
+                name: param2 as string,
+                component: param1 as T
+            });
+            scope = param3 instanceof A_Scope ? param3 : undefined;
+        }
+
+        const featureScope = scope || this.scope;
+
+        // create new caller for the chained feature
+        feature._caller = this._caller;
+
+        return feature.process(featureScope);
+    }
+
+
 
 
     toString(): string {

package/tests/A-Feature.test.ts

@@ -586,7 +586,7 @@ describe('A-Feature tests', () => {
         const executionResults: string[] = [];
 
         class BaseEntity extends A_Entity {
-           async test() {
+            async test() {
                 await this.call('myFeature');
             }
 
@@ -598,7 +598,7 @@ describe('A-Feature tests', () => {
                 name: 'myFeature',
                 scope: [BaseEntity]
             })
-             testMethod() {
+            testMethod() {
                 executionResults.push('testMethod');
             }
         }
@@ -625,4 +625,45 @@ describe('A-Feature tests', () => {
 
         expect(executionResults).toEqual(['testMethod', 'testMethod']);
     });
+    it('Should allow be possible to do a Feature Chaining without Caller Change', async () => {
+        const executionResults: string[] = [];
+
+        class Component_B extends A_Component {
+
+            @A_Feature.Extend()
+            featureB(
+                @A_Inject(A_Caller) caller: Component_A
+            ) {
+                executionResults.push('featureB');
+
+                expect(caller).toBeInstanceOf(Component_A);
+            }
+        }
+
+        class Component_A extends A_Component {
+
+            @A_Feature.Extend()
+            async featureA(
+                @A_Inject(A_Feature) feature: A_Feature,
+                @A_Inject(Component_B) compb: Component_B
+            ) {
+                executionResults.push('featureA');
+
+                await feature.chain(compb, 'featureB');
+            }
+        }
+
+
+
+        const scope = new A_Scope({ name: 'TestScope', components: [Component_A, Component_B] });
+
+
+        const compA = scope.resolve(Component_A)!;
+
+        await compA.call('featureA');
+
+        expect(executionResults).toEqual(['featureA', 'featureB']);
+
+
+    });
 });