@adaas/a-concept 0.1.53 → 0.1.55

package/package.json

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

@@ -703,10 +703,9 @@ export class A_Scope<
 
             case A_TypeGuards.isEntityConstructor(param1): {
                 // 3) Check entities
-                this.allowedEntities.forEach(ctor => {
-                    if (A_CommonHelper.isInheritedFrom(ctor, param1)) {
-                        const instance = this.resolve<T>(ctor);
-                        if (instance) results.push(instance as T);
+                this.entities.forEach(entity => {
+                    if (A_CommonHelper.isInheritedFrom(entity.constructor, param1)) {
+                        results.push(entity as T);
                     }
                 });
                 break;
@@ -740,13 +739,13 @@ export class A_Scope<
 
 
         const parentScope = this._parent;
-        
+
         while (parentScope && parentScope.has(param1 as any)) {
             const parentResults = parentScope.resolveAll<T>(param1 as any);
             results.push(...parentResults);
             break;
         }
-        
+
 
         return results;
     }

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

package/tests/A-Scope.test.ts

@@ -433,5 +433,23 @@ describe('A-Scope tests', () => {
         //  the first element should be instance of ComponentC as it is registered in child scope
         expect(resolvedComponents[0] instanceof ComponentC).toBe(true);
     });
+    it('Should resolve all entities registered in the scope', async () => {
 
+        class MyEntity extends A_Entity { }
+
+
+        const scope = new A_Scope({ name: 'TestScope' });
+
+        scope.register(new MyEntity());
+        scope.register(new MyEntity());
+        scope.register(new MyEntity());
+
+        const resolvedEntities = scope.resolveAll<MyEntity>(MyEntity);
+
+        expect(resolvedEntities.length).toBe(3);
+        resolvedEntities.forEach(entity => {
+            expect(entity).toBeInstanceOf(MyEntity);
+        });
+
+    });
 });