@adaas/a-concept 0.1.51 → 0.1.53

package/package.json

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

@@ -10,6 +10,7 @@ import { ASEID } from "../ASEID/ASEID.class";
 import { A_IdentityHelper } from "@adaas/a-concept/helpers/A_Identity.helper";
 import { A_EntityError } from "./A-Entity.error";
 import { A_Feature } from "../A-Feature/A-Feature.class";
+import { A_TYPES__ASEID_Constructor } from "../ASEID/ASEID.types";
 
 
 /**
@@ -239,6 +240,23 @@ export class A_Entity<
         throw new A_EntityError(A_EntityError.ValidationError, 'Unable to determine A-Entity constructor initialization method. Please check the provided parameters.');
     }
 
+    /**
+     * Generates a new ASEID for the entity. 
+     * It uses class definitions for concept, scope, and entity,
+     * and allows overriding any of these values.
+     * 
+     * @param override 
+     * @returns 
+     */
+    protected generateASEID(override?: Partial<A_TYPES__ASEID_Constructor>): ASEID {
+        return new ASEID({
+            concept: override?.concept || (this.constructor as typeof A_Entity).concept,
+            scope: override?.scope || (this.constructor as typeof A_Entity).scope,
+            entity: override?.entity || (this.constructor as typeof A_Entity).entity,
+            id: override?.id || A_IdentityHelper.generateTimeId()
+        });
+    }
+
 
     /**
      * Call a feature of the component with the provided scope
@@ -318,12 +336,8 @@ export class A_Entity<
      * @returns 
      */
     fromUndefined(): void {
-        this.aseid = new ASEID({
-            concept: (this.constructor as typeof A_Entity).concept,
-            scope: (this.constructor as typeof A_Entity).scope,
-            entity: (this.constructor as typeof A_Entity).entity,
-            id: A_IdentityHelper.generateTimeId()
-        });
+        this.aseid = this.generateASEID();
+        
         return;
     }
 
@@ -336,12 +350,7 @@ export class A_Entity<
      * @returns 
      */
     fromNew(newEntity: _ConstructorType): void {
-        this.aseid = new ASEID({
-            concept: (this.constructor as typeof A_Entity).concept,
-            scope: (this.constructor as typeof A_Entity).scope,
-            entity: (this.constructor as typeof A_Entity).entity,
-            id: A_IdentityHelper.generateTimeId()
-        });
+        this.aseid =  this.generateASEID();
 
         return;
     }

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