@adaas/a-concept 0.1.52 → 0.1.54

package/package.json

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

@@ -709,26 +709,33 @@ export class A_Context {
         if (!A_TypeGuards.isAllowedForFeatureDefinition(component))
             throw new A_ContextError(A_ContextError.InvalidFeatureExtensionParameterError, `Unable to get feature template. Component of type ${componentName} is not allowed for feature definition.`);
 
-        const callName = `${component.constructor.name}.${name}`;
+
+        const callNames = A_CommonHelper.getClassInheritanceChain(component)
+            .filter(c => c !== A_Component && c !== A_Container && c !== A_Entity)
+            .map(c => `${c.name}.${name}`);
+
+        // const callName = `${component.constructor.name}.${name}`;
 
         const steps: A_TYPES__A_StageStep[] = [];
 
-        // We need to get all components that has extensions for the feature in component
-        for (const [cmp, meta] of instance._metaStorage) {
-            // Just try to make sure that component not only Indexed but also presented in scope
-            if (scope.has(cmp) && (
-                A_TypeGuards.isComponentMetaInstance(meta)
-                || A_TypeGuards.isContainerMetaInstance(meta)
-            )) {
-                // Get all extensions for the feature
-                meta
-                    .extensions(callName)
-                    .forEach((declaration) => {
-                        steps.push({
-                            component: cmp,
-                            ...declaration
+        for (const callName of callNames) {
+            // We need to get all components that has extensions for the feature in component
+            for (const [cmp, meta] of instance._metaStorage) {
+                // Just try to make sure that component not only Indexed but also presented in scope
+                if (scope.has(cmp) && (
+                    A_TypeGuards.isComponentMetaInstance(meta)
+                    || A_TypeGuards.isContainerMetaInstance(meta)
+                )) {
+                    // Get all extensions for the feature
+                    meta
+                        .extensions(callName)
+                        .forEach((declaration) => {
+                            steps.push({
+                                component: cmp,
+                                ...declaration
+                            });
                         });
-                    });
+                }
             }
         }
 

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/helpers/A_Common.helper.ts

@@ -30,6 +30,68 @@ export class A_CommonHelper {
         return false;
     }
 
+
+    /**
+     * Get all parent classes of a given class
+     * 
+     * @param childClass 
+     * @returns 
+     */
+    static getParentClasses(childClass: any): any[] {
+
+        // first we need to check is that a constructor or instance
+        let current = typeof childClass === 'function'
+            ? Object.getPrototypeOf(childClass)
+            : Object.getPrototypeOf(childClass.constructor);
+
+        const parents = [] as any[];
+
+        // Traverse the prototype chain
+        while (current && current !== Function.prototype) {
+            parents.push(current);
+            current = Object.getPrototypeOf(current);
+        }
+        return parents;
+
+    }
+
+    /**
+     * Get the class inheritance chain as an array of class names
+     * 
+     * @param childClass 
+     * @returns 
+     */
+    static getClassInheritanceChain(childClass: any): any[] {
+
+        //  first we need to check is that a constructor or instance
+        let current = typeof childClass === 'function'
+            ? Object.getPrototypeOf(childClass)
+            : Object.getPrototypeOf(childClass.constructor);
+
+        //  then if input is instance we have to include its own class name
+        const chain = typeof childClass === 'function'
+            ? [childClass]
+            : [childClass.constructor];
+
+
+        // Traverse the prototype chain
+        while (current && current !== Function.prototype) {
+            chain.push(current);
+            current = Object.getPrototypeOf(current);
+        }
+        return chain;
+    }
+
+    /**
+     * Get the parent class of a given class
+     * 
+     * @param childClass 
+     * @returns 
+     */
+    static getParentClass(childClass: any): any {
+        return Object.getPrototypeOf(childClass);
+    }
+
     /**
      *  Omit properties from an object or array with nested objects
      * 

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_Error, A_TYPES__FeatureState } from "../src";
+import { A_Entity, A_Error, A_TYPES__FeatureState } from "../src";
 
 jest.retryTimes(0);
 
@@ -582,4 +582,88 @@ describe('A-Feature tests', () => {
         });
 
     }, 5000);
+    it('Should allow to use extension if only parent class provided', async () => {
+        const executionResults: string[] = [];
+
+        class BaseEntity extends A_Entity {
+            async test() {
+                await this.call('myFeature');
+            }
+
+        }
+
+        class MyComponent extends A_Component {
+
+            @A_Feature.Extend({
+                name: 'myFeature',
+                scope: [BaseEntity]
+            })
+            testMethod() {
+                executionResults.push('testMethod');
+            }
+        }
+
+        class My_Entity extends BaseEntity {
+
+        }
+
+        const scope = new A_Scope({ name: 'TestScope', components: [MyComponent] });
+
+
+        const myEntity = new My_Entity({ name: 'MyEntityInstance' });
+        const baseEntity = new BaseEntity({ name: 'BaseEntityInstance' });
+
+
+        scope.register(myEntity);
+        scope.register(baseEntity);
+
+        await baseEntity.test();
+
+        expect(executionResults).toEqual(['testMethod']);
+
+        await myEntity.test();
+
+        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']);
+
+
+    });
 });